commit d3bac575d42b7f003ca199cb59e64685b110c597
Author: Rumps <bgoldsworthy96@gmail.com>
Date:   Fri Apr 14 08:29:38 2017 +0100

    Initial commit

diff --git a/README.txt b/README.txt
new file mode 100644
index 0000000..a6d4eb5
--- /dev/null
+++ b/README.txt
@@ -0,0 +1 @@
+Visit http://www.lancaster.ac.uk/ug/goldswor/scc300/ for webpage.
\ No newline at end of file
diff --git a/dat/archives/difffile-html.bz2 b/dat/archives/difffile-html.bz2
new file mode 100644
index 0000000..12aff56
Binary files /dev/null and b/dat/archives/difffile-html.bz2 differ
diff --git a/dat/archives/difffile-images.bz2 b/dat/archives/difffile-images.bz2
new file mode 100644
index 0000000..fbfca6a
Binary files /dev/null and b/dat/archives/difffile-images.bz2 differ
diff --git a/dat/archives/difffile-large.bz2 b/dat/archives/difffile-large.bz2
new file mode 100644
index 0000000..d3eddfa
Binary files /dev/null and b/dat/archives/difffile-large.bz2 differ
diff --git a/dat/archives/difffile-small.bz2 b/dat/archives/difffile-small.bz2
new file mode 100644
index 0000000..2f6d565
Binary files /dev/null and b/dat/archives/difffile-small.bz2 differ
diff --git a/dat/archives/difffile.bz2 b/dat/archives/difffile.bz2
new file mode 100644
index 0000000..5cec74e
Binary files /dev/null and b/dat/archives/difffile.bz2 differ
diff --git a/dat/archives/samefile-html.bz2 b/dat/archives/samefile-html.bz2
new file mode 100644
index 0000000..d50e0fd
Binary files /dev/null and b/dat/archives/samefile-html.bz2 differ
diff --git a/dat/archives/samefile-images.bz2 b/dat/archives/samefile-images.bz2
new file mode 100644
index 0000000..d0efe3a
Binary files /dev/null and b/dat/archives/samefile-images.bz2 differ
diff --git a/dat/cache/CacheHandlerBase.dn b/dat/cache/CacheHandlerBase.dn
new file mode 100644
index 0000000..63bffc2
--- /dev/null
+++ b/dat/cache/CacheHandlerBase.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+            index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/Thumbs.db b/dat/cache/Thumbs.db
new file mode 100644
index 0000000..d91ff9e
Binary files /dev/null and b/dat/cache/Thumbs.db differ
diff --git a/dat/cache/difffile-large/0/CacheHandler0_0.dn b/dat/cache/difffile-large/0/CacheHandler0_0.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_0.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_1.dn b/dat/cache/difffile-large/0/CacheHandler0_1.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_1.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_10.dn b/dat/cache/difffile-large/0/CacheHandler0_10.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_10.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_11.dn b/dat/cache/difffile-large/0/CacheHandler0_11.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_11.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_12.dn b/dat/cache/difffile-large/0/CacheHandler0_12.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_12.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_13.dn b/dat/cache/difffile-large/0/CacheHandler0_13.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_13.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_14.dn b/dat/cache/difffile-large/0/CacheHandler0_14.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_14.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_15.dn b/dat/cache/difffile-large/0/CacheHandler0_15.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_15.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_16.dn b/dat/cache/difffile-large/0/CacheHandler0_16.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_16.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_17.dn b/dat/cache/difffile-large/0/CacheHandler0_17.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_17.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_18.dn b/dat/cache/difffile-large/0/CacheHandler0_18.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_18.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_19.dn b/dat/cache/difffile-large/0/CacheHandler0_19.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_19.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_2.dn b/dat/cache/difffile-large/0/CacheHandler0_2.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_2.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_20.dn b/dat/cache/difffile-large/0/CacheHandler0_20.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_20.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_21.dn b/dat/cache/difffile-large/0/CacheHandler0_21.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_21.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_22.dn b/dat/cache/difffile-large/0/CacheHandler0_22.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_22.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_23.dn b/dat/cache/difffile-large/0/CacheHandler0_23.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_23.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_24.dn b/dat/cache/difffile-large/0/CacheHandler0_24.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_24.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_25.dn b/dat/cache/difffile-large/0/CacheHandler0_25.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_25.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_26.dn b/dat/cache/difffile-large/0/CacheHandler0_26.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_26.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_27.dn b/dat/cache/difffile-large/0/CacheHandler0_27.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_27.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_28.dn b/dat/cache/difffile-large/0/CacheHandler0_28.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_28.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_29.dn b/dat/cache/difffile-large/0/CacheHandler0_29.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_29.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_3.dn b/dat/cache/difffile-large/0/CacheHandler0_3.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_3.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_30.dn b/dat/cache/difffile-large/0/CacheHandler0_30.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_30.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_31.dn b/dat/cache/difffile-large/0/CacheHandler0_31.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_31.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_32.dn b/dat/cache/difffile-large/0/CacheHandler0_32.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_32.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_33.dn b/dat/cache/difffile-large/0/CacheHandler0_33.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_33.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_34.dn b/dat/cache/difffile-large/0/CacheHandler0_34.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_34.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_4.dn b/dat/cache/difffile-large/0/CacheHandler0_4.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_4.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_5.dn b/dat/cache/difffile-large/0/CacheHandler0_5.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_5.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_6.dn b/dat/cache/difffile-large/0/CacheHandler0_6.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_6.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_7.dn b/dat/cache/difffile-large/0/CacheHandler0_7.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_7.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_8.dn b/dat/cache/difffile-large/0/CacheHandler0_8.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_8.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/0/CacheHandler0_9.dn b/dat/cache/difffile-large/0/CacheHandler0_9.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/0/CacheHandler0_9.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_0.dn b/dat/cache/difffile-large/1/CacheHandler1_0.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_0.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_1.dn b/dat/cache/difffile-large/1/CacheHandler1_1.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_1.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_10.dn b/dat/cache/difffile-large/1/CacheHandler1_10.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_10.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_11.dn b/dat/cache/difffile-large/1/CacheHandler1_11.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_11.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_12.dn b/dat/cache/difffile-large/1/CacheHandler1_12.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_12.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_13.dn b/dat/cache/difffile-large/1/CacheHandler1_13.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_13.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_14.dn b/dat/cache/difffile-large/1/CacheHandler1_14.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_14.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_15.dn b/dat/cache/difffile-large/1/CacheHandler1_15.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_15.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_16.dn b/dat/cache/difffile-large/1/CacheHandler1_16.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_16.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_17.dn b/dat/cache/difffile-large/1/CacheHandler1_17.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_17.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_18.dn b/dat/cache/difffile-large/1/CacheHandler1_18.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_18.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_19.dn b/dat/cache/difffile-large/1/CacheHandler1_19.dn
new file mode 100644
index 0000000..7168f0c
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_19.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*4
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_2.dn b/dat/cache/difffile-large/1/CacheHandler1_2.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_2.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_20.dn b/dat/cache/difffile-large/1/CacheHandler1_20.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_20.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_21.dn b/dat/cache/difffile-large/1/CacheHandler1_21.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_21.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_22.dn b/dat/cache/difffile-large/1/CacheHandler1_22.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_22.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_23.dn b/dat/cache/difffile-large/1/CacheHandler1_23.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_23.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_24.dn b/dat/cache/difffile-large/1/CacheHandler1_24.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_24.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_25.dn b/dat/cache/difffile-large/1/CacheHandler1_25.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_25.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_26.dn b/dat/cache/difffile-large/1/CacheHandler1_26.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_26.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_27.dn b/dat/cache/difffile-large/1/CacheHandler1_27.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_27.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_28.dn b/dat/cache/difffile-large/1/CacheHandler1_28.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_28.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_29.dn b/dat/cache/difffile-large/1/CacheHandler1_29.dn
new file mode 100644
index 0000000..541b5f2
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_29.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_3.dn b/dat/cache/difffile-large/1/CacheHandler1_3.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_3.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_30.dn b/dat/cache/difffile-large/1/CacheHandler1_30.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_30.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_31.dn b/dat/cache/difffile-large/1/CacheHandler1_31.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_31.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_32.dn b/dat/cache/difffile-large/1/CacheHandler1_32.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_32.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_33.dn b/dat/cache/difffile-large/1/CacheHandler1_33.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_33.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_34.dn b/dat/cache/difffile-large/1/CacheHandler1_34.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_34.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_4.dn b/dat/cache/difffile-large/1/CacheHandler1_4.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_4.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_5.dn b/dat/cache/difffile-large/1/CacheHandler1_5.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_5.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_6.dn b/dat/cache/difffile-large/1/CacheHandler1_6.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_6.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_7.dn b/dat/cache/difffile-large/1/CacheHandler1_7.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_7.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_8.dn b/dat/cache/difffile-large/1/CacheHandler1_8.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_8.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/1/CacheHandler1_9.dn b/dat/cache/difffile-large/1/CacheHandler1_9.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/1/CacheHandler1_9.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_0.dn b/dat/cache/difffile-large/10/CacheHandler10_0.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_0.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_1.dn b/dat/cache/difffile-large/10/CacheHandler10_1.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_1.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_10.dn b/dat/cache/difffile-large/10/CacheHandler10_10.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_10.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_11.dn b/dat/cache/difffile-large/10/CacheHandler10_11.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_11.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_12.dn b/dat/cache/difffile-large/10/CacheHandler10_12.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_12.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_13.dn b/dat/cache/difffile-large/10/CacheHandler10_13.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_13.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_14.dn b/dat/cache/difffile-large/10/CacheHandler10_14.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_14.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_15.dn b/dat/cache/difffile-large/10/CacheHandler10_15.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_15.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_16.dn b/dat/cache/difffile-large/10/CacheHandler10_16.dn
new file mode 100644
index 0000000..8ed43fc
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_16.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)/19
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_17.dn b/dat/cache/difffile-large/10/CacheHandler10_17.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_17.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_18.dn b/dat/cache/difffile-large/10/CacheHandler10_18.dn
new file mode 100644
index 0000000..cde4f6e
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_18.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_19.dn b/dat/cache/difffile-large/10/CacheHandler10_19.dn
new file mode 100644
index 0000000..627cd48
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_19.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 12-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_2.dn b/dat/cache/difffile-large/10/CacheHandler10_2.dn
new file mode 100644
index 0000000..219cc47
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_2.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_20.dn b/dat/cache/difffile-large/10/CacheHandler10_20.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_20.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_21.dn b/dat/cache/difffile-large/10/CacheHandler10_21.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_21.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_22.dn b/dat/cache/difffile-large/10/CacheHandler10_22.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_22.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_23.dn b/dat/cache/difffile-large/10/CacheHandler10_23.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_23.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_24.dn b/dat/cache/difffile-large/10/CacheHandler10_24.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_24.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_25.dn b/dat/cache/difffile-large/10/CacheHandler10_25.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_25.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_26.dn b/dat/cache/difffile-large/10/CacheHandler10_26.dn
new file mode 100644
index 0000000..0726947
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_26.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-2
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_27.dn b/dat/cache/difffile-large/10/CacheHandler10_27.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_27.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_28.dn b/dat/cache/difffile-large/10/CacheHandler10_28.dn
new file mode 100644
index 0000000..fd826ac
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_28.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_29.dn b/dat/cache/difffile-large/10/CacheHandler10_29.dn
new file mode 100644
index 0000000..541b5f2
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_29.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_3.dn b/dat/cache/difffile-large/10/CacheHandler10_3.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_3.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_30.dn b/dat/cache/difffile-large/10/CacheHandler10_30.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_30.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_31.dn b/dat/cache/difffile-large/10/CacheHandler10_31.dn
new file mode 100644
index 0000000..88d4397
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_31.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/random()
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_32.dn b/dat/cache/difffile-large/10/CacheHandler10_32.dn
new file mode 100644
index 0000000..e0999a5
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_32.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_33.dn b/dat/cache/difffile-large/10/CacheHandler10_33.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_33.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_34.dn b/dat/cache/difffile-large/10/CacheHandler10_34.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_34.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_4.dn b/dat/cache/difffile-large/10/CacheHandler10_4.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_4.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_5.dn b/dat/cache/difffile-large/10/CacheHandler10_5.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_5.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_6.dn b/dat/cache/difffile-large/10/CacheHandler10_6.dn
new file mode 100644
index 0000000..2e42711
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_6.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_7.dn b/dat/cache/difffile-large/10/CacheHandler10_7.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_7.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_8.dn b/dat/cache/difffile-large/10/CacheHandler10_8.dn
new file mode 100644
index 0000000..07667c8
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_8.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+2
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/10/CacheHandler10_9.dn b/dat/cache/difffile-large/10/CacheHandler10_9.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/10/CacheHandler10_9.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_0.dn b/dat/cache/difffile-large/11/CacheHandler11_0.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_0.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_1.dn b/dat/cache/difffile-large/11/CacheHandler11_1.dn
new file mode 100644
index 0000000..627cd48
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_1.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 12-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_10.dn b/dat/cache/difffile-large/11/CacheHandler11_10.dn
new file mode 100644
index 0000000..2e42711
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_10.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_11.dn b/dat/cache/difffile-large/11/CacheHandler11_11.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_11.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_12.dn b/dat/cache/difffile-large/11/CacheHandler11_12.dn
new file mode 100644
index 0000000..07667c8
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_12.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+2
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_13.dn b/dat/cache/difffile-large/11/CacheHandler11_13.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_13.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_14.dn b/dat/cache/difffile-large/11/CacheHandler11_14.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_14.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_15.dn b/dat/cache/difffile-large/11/CacheHandler11_15.dn
new file mode 100644
index 0000000..e0999a5
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_15.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_16.dn b/dat/cache/difffile-large/11/CacheHandler11_16.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_16.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_17.dn b/dat/cache/difffile-large/11/CacheHandler11_17.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_17.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_18.dn b/dat/cache/difffile-large/11/CacheHandler11_18.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_18.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_19.dn b/dat/cache/difffile-large/11/CacheHandler11_19.dn
new file mode 100644
index 0000000..8ed43fc
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_19.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)/19
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_2.dn b/dat/cache/difffile-large/11/CacheHandler11_2.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_2.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_20.dn b/dat/cache/difffile-large/11/CacheHandler11_20.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_20.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_21.dn b/dat/cache/difffile-large/11/CacheHandler11_21.dn
new file mode 100644
index 0000000..b5d7024
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_21.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)+nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_22.dn b/dat/cache/difffile-large/11/CacheHandler11_22.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_22.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_23.dn b/dat/cache/difffile-large/11/CacheHandler11_23.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_23.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_24.dn b/dat/cache/difffile-large/11/CacheHandler11_24.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_24.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_25.dn b/dat/cache/difffile-large/11/CacheHandler11_25.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_25.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_26.dn b/dat/cache/difffile-large/11/CacheHandler11_26.dn
new file mode 100644
index 0000000..dea93f4
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_26.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_27.dn b/dat/cache/difffile-large/11/CacheHandler11_27.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_27.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_28.dn b/dat/cache/difffile-large/11/CacheHandler11_28.dn
new file mode 100644
index 0000000..fd826ac
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_28.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_29.dn b/dat/cache/difffile-large/11/CacheHandler11_29.dn
new file mode 100644
index 0000000..541b5f2
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_29.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_3.dn b/dat/cache/difffile-large/11/CacheHandler11_3.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_3.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_30.dn b/dat/cache/difffile-large/11/CacheHandler11_30.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_30.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_31.dn b/dat/cache/difffile-large/11/CacheHandler11_31.dn
new file mode 100644
index 0000000..88d4397
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_31.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/random()
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_32.dn b/dat/cache/difffile-large/11/CacheHandler11_32.dn
new file mode 100644
index 0000000..e0999a5
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_32.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_33.dn b/dat/cache/difffile-large/11/CacheHandler11_33.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_33.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_34.dn b/dat/cache/difffile-large/11/CacheHandler11_34.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_34.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_4.dn b/dat/cache/difffile-large/11/CacheHandler11_4.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_4.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_5.dn b/dat/cache/difffile-large/11/CacheHandler11_5.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_5.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_6.dn b/dat/cache/difffile-large/11/CacheHandler11_6.dn
new file mode 100644
index 0000000..219cc47
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_6.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_7.dn b/dat/cache/difffile-large/11/CacheHandler11_7.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_7.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_8.dn b/dat/cache/difffile-large/11/CacheHandler11_8.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_8.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/11/CacheHandler11_9.dn b/dat/cache/difffile-large/11/CacheHandler11_9.dn
new file mode 100644
index 0000000..541b5f2
--- /dev/null
+++ b/dat/cache/difffile-large/11/CacheHandler11_9.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_0.dn b/dat/cache/difffile-large/12/CacheHandler12_0.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_0.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_1.dn b/dat/cache/difffile-large/12/CacheHandler12_1.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_1.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_10.dn b/dat/cache/difffile-large/12/CacheHandler12_10.dn
new file mode 100644
index 0000000..541b5f2
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_10.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_11.dn b/dat/cache/difffile-large/12/CacheHandler12_11.dn
new file mode 100644
index 0000000..2e42711
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_11.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_12.dn b/dat/cache/difffile-large/12/CacheHandler12_12.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_12.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_13.dn b/dat/cache/difffile-large/12/CacheHandler12_13.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_13.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_14.dn b/dat/cache/difffile-large/12/CacheHandler12_14.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_14.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_15.dn b/dat/cache/difffile-large/12/CacheHandler12_15.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_15.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_16.dn b/dat/cache/difffile-large/12/CacheHandler12_16.dn
new file mode 100644
index 0000000..451c75e
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_16.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 14-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_17.dn b/dat/cache/difffile-large/12/CacheHandler12_17.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_17.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_18.dn b/dat/cache/difffile-large/12/CacheHandler12_18.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_18.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_19.dn b/dat/cache/difffile-large/12/CacheHandler12_19.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_19.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_2.dn b/dat/cache/difffile-large/12/CacheHandler12_2.dn
new file mode 100644
index 0000000..627cd48
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_2.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 12-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_20.dn b/dat/cache/difffile-large/12/CacheHandler12_20.dn
new file mode 100644
index 0000000..9334046
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_20.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*13
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_21.dn b/dat/cache/difffile-large/12/CacheHandler12_21.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_21.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_22.dn b/dat/cache/difffile-large/12/CacheHandler12_22.dn
new file mode 100644
index 0000000..b5d7024
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_22.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)+nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_23.dn b/dat/cache/difffile-large/12/CacheHandler12_23.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_23.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_24.dn b/dat/cache/difffile-large/12/CacheHandler12_24.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_24.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_25.dn b/dat/cache/difffile-large/12/CacheHandler12_25.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_25.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_26.dn b/dat/cache/difffile-large/12/CacheHandler12_26.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_26.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_27.dn b/dat/cache/difffile-large/12/CacheHandler12_27.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_27.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_28.dn b/dat/cache/difffile-large/12/CacheHandler12_28.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_28.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_29.dn b/dat/cache/difffile-large/12/CacheHandler12_29.dn
new file mode 100644
index 0000000..541b5f2
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_29.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_3.dn b/dat/cache/difffile-large/12/CacheHandler12_3.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_3.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_30.dn b/dat/cache/difffile-large/12/CacheHandler12_30.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_30.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_31.dn b/dat/cache/difffile-large/12/CacheHandler12_31.dn
new file mode 100644
index 0000000..fcc56ef
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_31.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 11/random()
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_32.dn b/dat/cache/difffile-large/12/CacheHandler12_32.dn
new file mode 100644
index 0000000..e0999a5
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_32.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_33.dn b/dat/cache/difffile-large/12/CacheHandler12_33.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_33.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_34.dn b/dat/cache/difffile-large/12/CacheHandler12_34.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_34.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_4.dn b/dat/cache/difffile-large/12/CacheHandler12_4.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_4.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_5.dn b/dat/cache/difffile-large/12/CacheHandler12_5.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_5.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_6.dn b/dat/cache/difffile-large/12/CacheHandler12_6.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_6.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_7.dn b/dat/cache/difffile-large/12/CacheHandler12_7.dn
new file mode 100644
index 0000000..219cc47
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_7.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_8.dn b/dat/cache/difffile-large/12/CacheHandler12_8.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_8.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/12/CacheHandler12_9.dn b/dat/cache/difffile-large/12/CacheHandler12_9.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/12/CacheHandler12_9.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_0.dn b/dat/cache/difffile-large/13/CacheHandler13_0.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_0.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_1.dn b/dat/cache/difffile-large/13/CacheHandler13_1.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_1.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_10.dn b/dat/cache/difffile-large/13/CacheHandler13_10.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_10.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_11.dn b/dat/cache/difffile-large/13/CacheHandler13_11.dn
new file mode 100644
index 0000000..219cc47
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_11.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_12.dn b/dat/cache/difffile-large/13/CacheHandler13_12.dn
new file mode 100644
index 0000000..0f6afab
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_12.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_13.dn b/dat/cache/difffile-large/13/CacheHandler13_13.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_13.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_14.dn b/dat/cache/difffile-large/13/CacheHandler13_14.dn
new file mode 100644
index 0000000..541b5f2
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_14.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_15.dn b/dat/cache/difffile-large/13/CacheHandler13_15.dn
new file mode 100644
index 0000000..2e42711
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_15.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_16.dn b/dat/cache/difffile-large/13/CacheHandler13_16.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_16.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_17.dn b/dat/cache/difffile-large/13/CacheHandler13_17.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_17.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_18.dn b/dat/cache/difffile-large/13/CacheHandler13_18.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_18.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_19.dn b/dat/cache/difffile-large/13/CacheHandler13_19.dn
new file mode 100644
index 0000000..451c75e
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_19.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 14-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_2.dn b/dat/cache/difffile-large/13/CacheHandler13_2.dn
new file mode 100644
index 0000000..541b5f2
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_2.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_20.dn b/dat/cache/difffile-large/13/CacheHandler13_20.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_20.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_21.dn b/dat/cache/difffile-large/13/CacheHandler13_21.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_21.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_22.dn b/dat/cache/difffile-large/13/CacheHandler13_22.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_22.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_23.dn b/dat/cache/difffile-large/13/CacheHandler13_23.dn
new file mode 100644
index 0000000..9334046
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_23.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*13
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_24.dn b/dat/cache/difffile-large/13/CacheHandler13_24.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_24.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_25.dn b/dat/cache/difffile-large/13/CacheHandler13_25.dn
new file mode 100644
index 0000000..b5d7024
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_25.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)+nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_26.dn b/dat/cache/difffile-large/13/CacheHandler13_26.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_26.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_27.dn b/dat/cache/difffile-large/13/CacheHandler13_27.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_27.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_28.dn b/dat/cache/difffile-large/13/CacheHandler13_28.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_28.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_29.dn b/dat/cache/difffile-large/13/CacheHandler13_29.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_29.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_3.dn b/dat/cache/difffile-large/13/CacheHandler13_3.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_3.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_30.dn b/dat/cache/difffile-large/13/CacheHandler13_30.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_30.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_31.dn b/dat/cache/difffile-large/13/CacheHandler13_31.dn
new file mode 100644
index 0000000..fcc56ef
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_31.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 11/random()
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_32.dn b/dat/cache/difffile-large/13/CacheHandler13_32.dn
new file mode 100644
index 0000000..e0999a5
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_32.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_33.dn b/dat/cache/difffile-large/13/CacheHandler13_33.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_33.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_34.dn b/dat/cache/difffile-large/13/CacheHandler13_34.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_34.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_4.dn b/dat/cache/difffile-large/13/CacheHandler13_4.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_4.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_5.dn b/dat/cache/difffile-large/13/CacheHandler13_5.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_5.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_6.dn b/dat/cache/difffile-large/13/CacheHandler13_6.dn
new file mode 100644
index 0000000..627cd48
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_6.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 12-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_7.dn b/dat/cache/difffile-large/13/CacheHandler13_7.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_7.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_8.dn b/dat/cache/difffile-large/13/CacheHandler13_8.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_8.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/13/CacheHandler13_9.dn b/dat/cache/difffile-large/13/CacheHandler13_9.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/13/CacheHandler13_9.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_0.dn b/dat/cache/difffile-large/14/CacheHandler14_0.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_0.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_1.dn b/dat/cache/difffile-large/14/CacheHandler14_1.dn
new file mode 100644
index 0000000..e0999a5
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_1.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_10.dn b/dat/cache/difffile-large/14/CacheHandler14_10.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_10.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_11.dn b/dat/cache/difffile-large/14/CacheHandler14_11.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_11.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_12.dn b/dat/cache/difffile-large/14/CacheHandler14_12.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_12.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_13.dn b/dat/cache/difffile-large/14/CacheHandler14_13.dn
new file mode 100644
index 0000000..219cc47
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_13.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_14.dn b/dat/cache/difffile-large/14/CacheHandler14_14.dn
new file mode 100644
index 0000000..0f6afab
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_14.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_15.dn b/dat/cache/difffile-large/14/CacheHandler14_15.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_15.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_16.dn b/dat/cache/difffile-large/14/CacheHandler14_16.dn
new file mode 100644
index 0000000..541b5f2
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_16.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_17.dn b/dat/cache/difffile-large/14/CacheHandler14_17.dn
new file mode 100644
index 0000000..2e42711
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_17.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_18.dn b/dat/cache/difffile-large/14/CacheHandler14_18.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_18.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_19.dn b/dat/cache/difffile-large/14/CacheHandler14_19.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_19.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_2.dn b/dat/cache/difffile-large/14/CacheHandler14_2.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_2.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_20.dn b/dat/cache/difffile-large/14/CacheHandler14_20.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_20.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_21.dn b/dat/cache/difffile-large/14/CacheHandler14_21.dn
new file mode 100644
index 0000000..451c75e
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_21.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 14-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_22.dn b/dat/cache/difffile-large/14/CacheHandler14_22.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_22.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_23.dn b/dat/cache/difffile-large/14/CacheHandler14_23.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_23.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_24.dn b/dat/cache/difffile-large/14/CacheHandler14_24.dn
new file mode 100644
index 0000000..9334046
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_24.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*13
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_25.dn b/dat/cache/difffile-large/14/CacheHandler14_25.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_25.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_26.dn b/dat/cache/difffile-large/14/CacheHandler14_26.dn
new file mode 100644
index 0000000..b5d7024
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_26.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)+nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_27.dn b/dat/cache/difffile-large/14/CacheHandler14_27.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_27.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_28.dn b/dat/cache/difffile-large/14/CacheHandler14_28.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_28.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_29.dn b/dat/cache/difffile-large/14/CacheHandler14_29.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_29.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_3.dn b/dat/cache/difffile-large/14/CacheHandler14_3.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_3.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_30.dn b/dat/cache/difffile-large/14/CacheHandler14_30.dn
new file mode 100644
index 0000000..2e42711
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_30.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_31.dn b/dat/cache/difffile-large/14/CacheHandler14_31.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_31.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_32.dn b/dat/cache/difffile-large/14/CacheHandler14_32.dn
new file mode 100644
index 0000000..fcc56ef
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_32.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 11/random()
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_33.dn b/dat/cache/difffile-large/14/CacheHandler14_33.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_33.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_34.dn b/dat/cache/difffile-large/14/CacheHandler14_34.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_34.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_4.dn b/dat/cache/difffile-large/14/CacheHandler14_4.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_4.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_5.dn b/dat/cache/difffile-large/14/CacheHandler14_5.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_5.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_6.dn b/dat/cache/difffile-large/14/CacheHandler14_6.dn
new file mode 100644
index 0000000..541b5f2
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_6.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_7.dn b/dat/cache/difffile-large/14/CacheHandler14_7.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_7.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_8.dn b/dat/cache/difffile-large/14/CacheHandler14_8.dn
new file mode 100644
index 0000000..04b26cb
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_8.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 8+nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/14/CacheHandler14_9.dn b/dat/cache/difffile-large/14/CacheHandler14_9.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/14/CacheHandler14_9.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_0.dn b/dat/cache/difffile-large/15/CacheHandler15_0.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_0.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_1.dn b/dat/cache/difffile-large/15/CacheHandler15_1.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_1.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_10.dn b/dat/cache/difffile-large/15/CacheHandler15_10.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_10.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_11.dn b/dat/cache/difffile-large/15/CacheHandler15_11.dn
new file mode 100644
index 0000000..1a417c7
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_11.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)+nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_12.dn b/dat/cache/difffile-large/15/CacheHandler15_12.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_12.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_13.dn b/dat/cache/difffile-large/15/CacheHandler15_13.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_13.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_14.dn b/dat/cache/difffile-large/15/CacheHandler15_14.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_14.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_15.dn b/dat/cache/difffile-large/15/CacheHandler15_15.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_15.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_16.dn b/dat/cache/difffile-large/15/CacheHandler15_16.dn
new file mode 100644
index 0000000..219cc47
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_16.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_17.dn b/dat/cache/difffile-large/15/CacheHandler15_17.dn
new file mode 100644
index 0000000..0f6afab
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_17.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_18.dn b/dat/cache/difffile-large/15/CacheHandler15_18.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_18.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_19.dn b/dat/cache/difffile-large/15/CacheHandler15_19.dn
new file mode 100644
index 0000000..541b5f2
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_19.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_2.dn b/dat/cache/difffile-large/15/CacheHandler15_2.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_2.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_20.dn b/dat/cache/difffile-large/15/CacheHandler15_20.dn
new file mode 100644
index 0000000..2e42711
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_20.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_21.dn b/dat/cache/difffile-large/15/CacheHandler15_21.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_21.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_22.dn b/dat/cache/difffile-large/15/CacheHandler15_22.dn
new file mode 100644
index 0000000..adb6367
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_22.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)+nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_23.dn b/dat/cache/difffile-large/15/CacheHandler15_23.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_23.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_24.dn b/dat/cache/difffile-large/15/CacheHandler15_24.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_24.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_25.dn b/dat/cache/difffile-large/15/CacheHandler15_25.dn
new file mode 100644
index 0000000..9334046
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_25.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*13
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_26.dn b/dat/cache/difffile-large/15/CacheHandler15_26.dn
new file mode 100644
index 0000000..2e8d0c2
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_26.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 19*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_27.dn b/dat/cache/difffile-large/15/CacheHandler15_27.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_27.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_28.dn b/dat/cache/difffile-large/15/CacheHandler15_28.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_28.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_29.dn b/dat/cache/difffile-large/15/CacheHandler15_29.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_29.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_3.dn b/dat/cache/difffile-large/15/CacheHandler15_3.dn
new file mode 100644
index 0000000..e0999a5
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_3.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_30.dn b/dat/cache/difffile-large/15/CacheHandler15_30.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_30.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_31.dn b/dat/cache/difffile-large/15/CacheHandler15_31.dn
new file mode 100644
index 0000000..2e42711
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_31.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_32.dn b/dat/cache/difffile-large/15/CacheHandler15_32.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_32.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_33.dn b/dat/cache/difffile-large/15/CacheHandler15_33.dn
new file mode 100644
index 0000000..fcc56ef
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_33.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 11/random()
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_34.dn b/dat/cache/difffile-large/15/CacheHandler15_34.dn
new file mode 100644
index 0000000..0f6afab
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_34.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_4.dn b/dat/cache/difffile-large/15/CacheHandler15_4.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_4.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_5.dn b/dat/cache/difffile-large/15/CacheHandler15_5.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_5.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_6.dn b/dat/cache/difffile-large/15/CacheHandler15_6.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_6.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_7.dn b/dat/cache/difffile-large/15/CacheHandler15_7.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_7.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_8.dn b/dat/cache/difffile-large/15/CacheHandler15_8.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_8.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/15/CacheHandler15_9.dn b/dat/cache/difffile-large/15/CacheHandler15_9.dn
new file mode 100644
index 0000000..541b5f2
--- /dev/null
+++ b/dat/cache/difffile-large/15/CacheHandler15_9.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_0.dn b/dat/cache/difffile-large/16/CacheHandler16_0.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_0.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_1.dn b/dat/cache/difffile-large/16/CacheHandler16_1.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_1.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_10.dn b/dat/cache/difffile-large/16/CacheHandler16_10.dn
new file mode 100644
index 0000000..541b5f2
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_10.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_11.dn b/dat/cache/difffile-large/16/CacheHandler16_11.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_11.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_12.dn b/dat/cache/difffile-large/16/CacheHandler16_12.dn
new file mode 100644
index 0000000..1a417c7
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_12.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)+nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_13.dn b/dat/cache/difffile-large/16/CacheHandler16_13.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_13.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_14.dn b/dat/cache/difffile-large/16/CacheHandler16_14.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_14.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_15.dn b/dat/cache/difffile-large/16/CacheHandler16_15.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_15.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_16.dn b/dat/cache/difffile-large/16/CacheHandler16_16.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_16.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_17.dn b/dat/cache/difffile-large/16/CacheHandler16_17.dn
new file mode 100644
index 0000000..219cc47
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_17.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_18.dn b/dat/cache/difffile-large/16/CacheHandler16_18.dn
new file mode 100644
index 0000000..0f6afab
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_18.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_19.dn b/dat/cache/difffile-large/16/CacheHandler16_19.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_19.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_2.dn b/dat/cache/difffile-large/16/CacheHandler16_2.dn
new file mode 100644
index 0000000..e0999a5
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_2.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_20.dn b/dat/cache/difffile-large/16/CacheHandler16_20.dn
new file mode 100644
index 0000000..541b5f2
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_20.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_21.dn b/dat/cache/difffile-large/16/CacheHandler16_21.dn
new file mode 100644
index 0000000..2e42711
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_21.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_22.dn b/dat/cache/difffile-large/16/CacheHandler16_22.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_22.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_23.dn b/dat/cache/difffile-large/16/CacheHandler16_23.dn
new file mode 100644
index 0000000..adb6367
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_23.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)+nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_24.dn b/dat/cache/difffile-large/16/CacheHandler16_24.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_24.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_25.dn b/dat/cache/difffile-large/16/CacheHandler16_25.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_25.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_26.dn b/dat/cache/difffile-large/16/CacheHandler16_26.dn
new file mode 100644
index 0000000..9334046
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_26.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*13
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_27.dn b/dat/cache/difffile-large/16/CacheHandler16_27.dn
new file mode 100644
index 0000000..2e8d0c2
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_27.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 19*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_28.dn b/dat/cache/difffile-large/16/CacheHandler16_28.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_28.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_29.dn b/dat/cache/difffile-large/16/CacheHandler16_29.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_29.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_3.dn b/dat/cache/difffile-large/16/CacheHandler16_3.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_3.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_30.dn b/dat/cache/difffile-large/16/CacheHandler16_30.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_30.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_31.dn b/dat/cache/difffile-large/16/CacheHandler16_31.dn
new file mode 100644
index 0000000..2e42711
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_31.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_32.dn b/dat/cache/difffile-large/16/CacheHandler16_32.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_32.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_33.dn b/dat/cache/difffile-large/16/CacheHandler16_33.dn
new file mode 100644
index 0000000..fcc56ef
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_33.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 11/random()
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_34.dn b/dat/cache/difffile-large/16/CacheHandler16_34.dn
new file mode 100644
index 0000000..b437d79
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_34.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_4.dn b/dat/cache/difffile-large/16/CacheHandler16_4.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_4.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_5.dn b/dat/cache/difffile-large/16/CacheHandler16_5.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_5.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_6.dn b/dat/cache/difffile-large/16/CacheHandler16_6.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_6.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_7.dn b/dat/cache/difffile-large/16/CacheHandler16_7.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_7.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_8.dn b/dat/cache/difffile-large/16/CacheHandler16_8.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_8.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/16/CacheHandler16_9.dn b/dat/cache/difffile-large/16/CacheHandler16_9.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/16/CacheHandler16_9.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_0.dn b/dat/cache/difffile-large/17/CacheHandler17_0.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_0.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_1.dn b/dat/cache/difffile-large/17/CacheHandler17_1.dn
new file mode 100644
index 0000000..e0999a5
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_1.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_10.dn b/dat/cache/difffile-large/17/CacheHandler17_10.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_10.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_11.dn b/dat/cache/difffile-large/17/CacheHandler17_11.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_11.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_12.dn b/dat/cache/difffile-large/17/CacheHandler17_12.dn
new file mode 100644
index 0000000..1a417c7
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_12.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)+nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_13.dn b/dat/cache/difffile-large/17/CacheHandler17_13.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_13.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_14.dn b/dat/cache/difffile-large/17/CacheHandler17_14.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_14.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_15.dn b/dat/cache/difffile-large/17/CacheHandler17_15.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_15.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_16.dn b/dat/cache/difffile-large/17/CacheHandler17_16.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_16.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_17.dn b/dat/cache/difffile-large/17/CacheHandler17_17.dn
new file mode 100644
index 0000000..219cc47
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_17.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_18.dn b/dat/cache/difffile-large/17/CacheHandler17_18.dn
new file mode 100644
index 0000000..0f6afab
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_18.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_19.dn b/dat/cache/difffile-large/17/CacheHandler17_19.dn
new file mode 100644
index 0000000..69c171f
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_19.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*3
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_2.dn b/dat/cache/difffile-large/17/CacheHandler17_2.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_2.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_20.dn b/dat/cache/difffile-large/17/CacheHandler17_20.dn
new file mode 100644
index 0000000..adb6367
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_20.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)+nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_21.dn b/dat/cache/difffile-large/17/CacheHandler17_21.dn
new file mode 100644
index 0000000..2e42711
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_21.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_22.dn b/dat/cache/difffile-large/17/CacheHandler17_22.dn
new file mode 100644
index 0000000..cde4f6e
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_22.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_23.dn b/dat/cache/difffile-large/17/CacheHandler17_23.dn
new file mode 100644
index 0000000..adb6367
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_23.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)+nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_24.dn b/dat/cache/difffile-large/17/CacheHandler17_24.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_24.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_25.dn b/dat/cache/difffile-large/17/CacheHandler17_25.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_25.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_26.dn b/dat/cache/difffile-large/17/CacheHandler17_26.dn
new file mode 100644
index 0000000..9334046
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_26.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*13
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_27.dn b/dat/cache/difffile-large/17/CacheHandler17_27.dn
new file mode 100644
index 0000000..2e8d0c2
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_27.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 19*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_28.dn b/dat/cache/difffile-large/17/CacheHandler17_28.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_28.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_29.dn b/dat/cache/difffile-large/17/CacheHandler17_29.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_29.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_3.dn b/dat/cache/difffile-large/17/CacheHandler17_3.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_3.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_30.dn b/dat/cache/difffile-large/17/CacheHandler17_30.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_30.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_31.dn b/dat/cache/difffile-large/17/CacheHandler17_31.dn
new file mode 100644
index 0000000..2e42711
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_31.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_32.dn b/dat/cache/difffile-large/17/CacheHandler17_32.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_32.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_33.dn b/dat/cache/difffile-large/17/CacheHandler17_33.dn
new file mode 100644
index 0000000..fcc56ef
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_33.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 11/random()
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_34.dn b/dat/cache/difffile-large/17/CacheHandler17_34.dn
new file mode 100644
index 0000000..b437d79
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_34.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_4.dn b/dat/cache/difffile-large/17/CacheHandler17_4.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_4.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_5.dn b/dat/cache/difffile-large/17/CacheHandler17_5.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_5.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_6.dn b/dat/cache/difffile-large/17/CacheHandler17_6.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_6.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_7.dn b/dat/cache/difffile-large/17/CacheHandler17_7.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_7.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_8.dn b/dat/cache/difffile-large/17/CacheHandler17_8.dn
new file mode 100644
index 0000000..219cc47
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_8.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/CacheHandler17_9.dn b/dat/cache/difffile-large/17/CacheHandler17_9.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/17/CacheHandler17_9.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/17/chromosomes.txt b/dat/cache/difffile-large/17/chromosomes.txt
new file mode 100644
index 0000000..5f712b9
--- /dev/null
+++ b/dat/cache/difffile-large/17/chromosomes.txt
@@ -0,0 +1,35 @@
+index = 0
+index = 0-nthMostFrequentlyUsed(0)
+index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+index = 0
+index = 0*nthMostRecentlyUsed(0)
+index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+index = 0
+index = 0-nthMostRecentlyUsed(0)
+index = 0
+index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+index = nthMostRecentlyUsed(0)+nthMostRecentlyUsed(0)
+index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+index = 0/nthMostRecentlyUsed(0)
+index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+index = 0-nthMostRecentlyUsed(0)
+index = nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+index = 0*3
+index = nthMostFrequentlyUsed(0)+nthMostFrequentlyUsed(0)
+index = nthMostRecentlyUsed(0)*nthMostFrequentlyUsed(0)
+index = 0+nthMostRecentlyUsed(0)
+index = nthMostFrequentlyUsed(0)+nthMostFrequentlyUsed(0)
+index = 0
+index = 0
+index = nthMostRecentlyUsed(0)*13
+index = 19*nthMostRecentlyUsed(0)
+index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+index = 0
+index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+index = nthMostRecentlyUsed(0)*nthMostFrequentlyUsed(0)
+index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+index = 11/random()
+index = nthMostRecentlyUsed(0)-nthMostRecentlyUsed(0)
\ No newline at end of file
diff --git a/dat/cache/difffile-large/2/CacheHandler2_0.dn b/dat/cache/difffile-large/2/CacheHandler2_0.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_0.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_1.dn b/dat/cache/difffile-large/2/CacheHandler2_1.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_1.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_10.dn b/dat/cache/difffile-large/2/CacheHandler2_10.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_10.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_11.dn b/dat/cache/difffile-large/2/CacheHandler2_11.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_11.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_12.dn b/dat/cache/difffile-large/2/CacheHandler2_12.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_12.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_13.dn b/dat/cache/difffile-large/2/CacheHandler2_13.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_13.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_14.dn b/dat/cache/difffile-large/2/CacheHandler2_14.dn
new file mode 100644
index 0000000..b032ee0
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_14.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+15
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_15.dn b/dat/cache/difffile-large/2/CacheHandler2_15.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_15.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_16.dn b/dat/cache/difffile-large/2/CacheHandler2_16.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_16.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_17.dn b/dat/cache/difffile-large/2/CacheHandler2_17.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_17.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_18.dn b/dat/cache/difffile-large/2/CacheHandler2_18.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_18.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_19.dn b/dat/cache/difffile-large/2/CacheHandler2_19.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_19.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_2.dn b/dat/cache/difffile-large/2/CacheHandler2_2.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_2.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_20.dn b/dat/cache/difffile-large/2/CacheHandler2_20.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_20.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_21.dn b/dat/cache/difffile-large/2/CacheHandler2_21.dn
new file mode 100644
index 0000000..7168f0c
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_21.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*4
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_22.dn b/dat/cache/difffile-large/2/CacheHandler2_22.dn
new file mode 100644
index 0000000..219cc47
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_22.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_23.dn b/dat/cache/difffile-large/2/CacheHandler2_23.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_23.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_24.dn b/dat/cache/difffile-large/2/CacheHandler2_24.dn
new file mode 100644
index 0000000..954e3b6
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_24.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+16
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_25.dn b/dat/cache/difffile-large/2/CacheHandler2_25.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_25.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_26.dn b/dat/cache/difffile-large/2/CacheHandler2_26.dn
new file mode 100644
index 0000000..351e233
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_26.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_27.dn b/dat/cache/difffile-large/2/CacheHandler2_27.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_27.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_28.dn b/dat/cache/difffile-large/2/CacheHandler2_28.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_28.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_29.dn b/dat/cache/difffile-large/2/CacheHandler2_29.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_29.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_3.dn b/dat/cache/difffile-large/2/CacheHandler2_3.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_3.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_30.dn b/dat/cache/difffile-large/2/CacheHandler2_30.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_30.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_31.dn b/dat/cache/difffile-large/2/CacheHandler2_31.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_31.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_32.dn b/dat/cache/difffile-large/2/CacheHandler2_32.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_32.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_33.dn b/dat/cache/difffile-large/2/CacheHandler2_33.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_33.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_34.dn b/dat/cache/difffile-large/2/CacheHandler2_34.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_34.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_4.dn b/dat/cache/difffile-large/2/CacheHandler2_4.dn
new file mode 100644
index 0000000..219cc47
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_4.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_5.dn b/dat/cache/difffile-large/2/CacheHandler2_5.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_5.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_6.dn b/dat/cache/difffile-large/2/CacheHandler2_6.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_6.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_7.dn b/dat/cache/difffile-large/2/CacheHandler2_7.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_7.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_8.dn b/dat/cache/difffile-large/2/CacheHandler2_8.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_8.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/2/CacheHandler2_9.dn b/dat/cache/difffile-large/2/CacheHandler2_9.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/2/CacheHandler2_9.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_0.dn b/dat/cache/difffile-large/3/CacheHandler3_0.dn
new file mode 100644
index 0000000..219cc47
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_0.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_1.dn b/dat/cache/difffile-large/3/CacheHandler3_1.dn
new file mode 100644
index 0000000..219cc47
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_1.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_10.dn b/dat/cache/difffile-large/3/CacheHandler3_10.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_10.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_11.dn b/dat/cache/difffile-large/3/CacheHandler3_11.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_11.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_12.dn b/dat/cache/difffile-large/3/CacheHandler3_12.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_12.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_13.dn b/dat/cache/difffile-large/3/CacheHandler3_13.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_13.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_14.dn b/dat/cache/difffile-large/3/CacheHandler3_14.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_14.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_15.dn b/dat/cache/difffile-large/3/CacheHandler3_15.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_15.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_16.dn b/dat/cache/difffile-large/3/CacheHandler3_16.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_16.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_17.dn b/dat/cache/difffile-large/3/CacheHandler3_17.dn
new file mode 100644
index 0000000..b032ee0
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_17.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+15
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_18.dn b/dat/cache/difffile-large/3/CacheHandler3_18.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_18.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_19.dn b/dat/cache/difffile-large/3/CacheHandler3_19.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_19.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_2.dn b/dat/cache/difffile-large/3/CacheHandler3_2.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_2.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_20.dn b/dat/cache/difffile-large/3/CacheHandler3_20.dn
new file mode 100644
index 0000000..9261fe9
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_20.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 18*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_21.dn b/dat/cache/difffile-large/3/CacheHandler3_21.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_21.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_22.dn b/dat/cache/difffile-large/3/CacheHandler3_22.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_22.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_23.dn b/dat/cache/difffile-large/3/CacheHandler3_23.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_23.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_24.dn b/dat/cache/difffile-large/3/CacheHandler3_24.dn
new file mode 100644
index 0000000..7168f0c
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_24.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*4
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_25.dn b/dat/cache/difffile-large/3/CacheHandler3_25.dn
new file mode 100644
index 0000000..c0b2fdb
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_25.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)+3
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_26.dn b/dat/cache/difffile-large/3/CacheHandler3_26.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_26.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_27.dn b/dat/cache/difffile-large/3/CacheHandler3_27.dn
new file mode 100644
index 0000000..351e233
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_27.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_28.dn b/dat/cache/difffile-large/3/CacheHandler3_28.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_28.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_29.dn b/dat/cache/difffile-large/3/CacheHandler3_29.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_29.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_3.dn b/dat/cache/difffile-large/3/CacheHandler3_3.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_3.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_30.dn b/dat/cache/difffile-large/3/CacheHandler3_30.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_30.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_31.dn b/dat/cache/difffile-large/3/CacheHandler3_31.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_31.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_32.dn b/dat/cache/difffile-large/3/CacheHandler3_32.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_32.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_33.dn b/dat/cache/difffile-large/3/CacheHandler3_33.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_33.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_34.dn b/dat/cache/difffile-large/3/CacheHandler3_34.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_34.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_4.dn b/dat/cache/difffile-large/3/CacheHandler3_4.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_4.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_5.dn b/dat/cache/difffile-large/3/CacheHandler3_5.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_5.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_6.dn b/dat/cache/difffile-large/3/CacheHandler3_6.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_6.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_7.dn b/dat/cache/difffile-large/3/CacheHandler3_7.dn
new file mode 100644
index 0000000..cde4f6e
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_7.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_8.dn b/dat/cache/difffile-large/3/CacheHandler3_8.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_8.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/3/CacheHandler3_9.dn b/dat/cache/difffile-large/3/CacheHandler3_9.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/3/CacheHandler3_9.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_0.dn b/dat/cache/difffile-large/4/CacheHandler4_0.dn
new file mode 100644
index 0000000..cde4f6e
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_0.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_1.dn b/dat/cache/difffile-large/4/CacheHandler4_1.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_1.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_10.dn b/dat/cache/difffile-large/4/CacheHandler4_10.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_10.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_11.dn b/dat/cache/difffile-large/4/CacheHandler4_11.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_11.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_12.dn b/dat/cache/difffile-large/4/CacheHandler4_12.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_12.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_13.dn b/dat/cache/difffile-large/4/CacheHandler4_13.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_13.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_14.dn b/dat/cache/difffile-large/4/CacheHandler4_14.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_14.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_15.dn b/dat/cache/difffile-large/4/CacheHandler4_15.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_15.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_16.dn b/dat/cache/difffile-large/4/CacheHandler4_16.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_16.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_17.dn b/dat/cache/difffile-large/4/CacheHandler4_17.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_17.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_18.dn b/dat/cache/difffile-large/4/CacheHandler4_18.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_18.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_19.dn b/dat/cache/difffile-large/4/CacheHandler4_19.dn
new file mode 100644
index 0000000..b032ee0
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_19.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+15
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_2.dn b/dat/cache/difffile-large/4/CacheHandler4_2.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_2.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_20.dn b/dat/cache/difffile-large/4/CacheHandler4_20.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_20.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_21.dn b/dat/cache/difffile-large/4/CacheHandler4_21.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_21.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_22.dn b/dat/cache/difffile-large/4/CacheHandler4_22.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_22.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_23.dn b/dat/cache/difffile-large/4/CacheHandler4_23.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_23.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_24.dn b/dat/cache/difffile-large/4/CacheHandler4_24.dn
new file mode 100644
index 0000000..7168f0c
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_24.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*4
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_25.dn b/dat/cache/difffile-large/4/CacheHandler4_25.dn
new file mode 100644
index 0000000..c0b2fdb
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_25.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)+3
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_26.dn b/dat/cache/difffile-large/4/CacheHandler4_26.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_26.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_27.dn b/dat/cache/difffile-large/4/CacheHandler4_27.dn
new file mode 100644
index 0000000..351e233
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_27.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_28.dn b/dat/cache/difffile-large/4/CacheHandler4_28.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_28.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_29.dn b/dat/cache/difffile-large/4/CacheHandler4_29.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_29.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_3.dn b/dat/cache/difffile-large/4/CacheHandler4_3.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_3.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_30.dn b/dat/cache/difffile-large/4/CacheHandler4_30.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_30.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_31.dn b/dat/cache/difffile-large/4/CacheHandler4_31.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_31.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_32.dn b/dat/cache/difffile-large/4/CacheHandler4_32.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_32.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_33.dn b/dat/cache/difffile-large/4/CacheHandler4_33.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_33.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_34.dn b/dat/cache/difffile-large/4/CacheHandler4_34.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_34.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_4.dn b/dat/cache/difffile-large/4/CacheHandler4_4.dn
new file mode 100644
index 0000000..627cd48
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_4.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 12-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_5.dn b/dat/cache/difffile-large/4/CacheHandler4_5.dn
new file mode 100644
index 0000000..4e54031
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_5.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 9-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_6.dn b/dat/cache/difffile-large/4/CacheHandler4_6.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_6.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_7.dn b/dat/cache/difffile-large/4/CacheHandler4_7.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_7.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_8.dn b/dat/cache/difffile-large/4/CacheHandler4_8.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_8.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/4/CacheHandler4_9.dn b/dat/cache/difffile-large/4/CacheHandler4_9.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/4/CacheHandler4_9.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_0.dn b/dat/cache/difffile-large/5/CacheHandler5_0.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_0.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_1.dn b/dat/cache/difffile-large/5/CacheHandler5_1.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_1.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_10.dn b/dat/cache/difffile-large/5/CacheHandler5_10.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_10.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_11.dn b/dat/cache/difffile-large/5/CacheHandler5_11.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_11.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_12.dn b/dat/cache/difffile-large/5/CacheHandler5_12.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_12.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_13.dn b/dat/cache/difffile-large/5/CacheHandler5_13.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_13.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_14.dn b/dat/cache/difffile-large/5/CacheHandler5_14.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_14.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_15.dn b/dat/cache/difffile-large/5/CacheHandler5_15.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_15.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_16.dn b/dat/cache/difffile-large/5/CacheHandler5_16.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_16.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_17.dn b/dat/cache/difffile-large/5/CacheHandler5_17.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_17.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_18.dn b/dat/cache/difffile-large/5/CacheHandler5_18.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_18.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_19.dn b/dat/cache/difffile-large/5/CacheHandler5_19.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_19.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_2.dn b/dat/cache/difffile-large/5/CacheHandler5_2.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_2.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_20.dn b/dat/cache/difffile-large/5/CacheHandler5_20.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_20.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_21.dn b/dat/cache/difffile-large/5/CacheHandler5_21.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_21.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_22.dn b/dat/cache/difffile-large/5/CacheHandler5_22.dn
new file mode 100644
index 0000000..3c39931
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_22.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 15/2
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_23.dn b/dat/cache/difffile-large/5/CacheHandler5_23.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_23.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_24.dn b/dat/cache/difffile-large/5/CacheHandler5_24.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_24.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_25.dn b/dat/cache/difffile-large/5/CacheHandler5_25.dn
new file mode 100644
index 0000000..7168f0c
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_25.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*4
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_26.dn b/dat/cache/difffile-large/5/CacheHandler5_26.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_26.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_27.dn b/dat/cache/difffile-large/5/CacheHandler5_27.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_27.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_28.dn b/dat/cache/difffile-large/5/CacheHandler5_28.dn
new file mode 100644
index 0000000..351e233
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_28.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_29.dn b/dat/cache/difffile-large/5/CacheHandler5_29.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_29.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_3.dn b/dat/cache/difffile-large/5/CacheHandler5_3.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_3.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_30.dn b/dat/cache/difffile-large/5/CacheHandler5_30.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_30.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_31.dn b/dat/cache/difffile-large/5/CacheHandler5_31.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_31.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_32.dn b/dat/cache/difffile-large/5/CacheHandler5_32.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_32.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_33.dn b/dat/cache/difffile-large/5/CacheHandler5_33.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_33.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_34.dn b/dat/cache/difffile-large/5/CacheHandler5_34.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_34.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_4.dn b/dat/cache/difffile-large/5/CacheHandler5_4.dn
new file mode 100644
index 0000000..cde4f6e
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_4.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_5.dn b/dat/cache/difffile-large/5/CacheHandler5_5.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_5.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_6.dn b/dat/cache/difffile-large/5/CacheHandler5_6.dn
new file mode 100644
index 0000000..e0999a5
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_6.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_7.dn b/dat/cache/difffile-large/5/CacheHandler5_7.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_7.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_8.dn b/dat/cache/difffile-large/5/CacheHandler5_8.dn
new file mode 100644
index 0000000..627cd48
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_8.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 12-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/5/CacheHandler5_9.dn b/dat/cache/difffile-large/5/CacheHandler5_9.dn
new file mode 100644
index 0000000..4e54031
--- /dev/null
+++ b/dat/cache/difffile-large/5/CacheHandler5_9.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 9-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_0.dn b/dat/cache/difffile-large/6/CacheHandler6_0.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_0.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_1.dn b/dat/cache/difffile-large/6/CacheHandler6_1.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_1.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_10.dn b/dat/cache/difffile-large/6/CacheHandler6_10.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_10.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_11.dn b/dat/cache/difffile-large/6/CacheHandler6_11.dn
new file mode 100644
index 0000000..627cd48
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_11.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 12-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_12.dn b/dat/cache/difffile-large/6/CacheHandler6_12.dn
new file mode 100644
index 0000000..4e54031
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_12.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 9-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_13.dn b/dat/cache/difffile-large/6/CacheHandler6_13.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_13.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_14.dn b/dat/cache/difffile-large/6/CacheHandler6_14.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_14.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_15.dn b/dat/cache/difffile-large/6/CacheHandler6_15.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_15.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_16.dn b/dat/cache/difffile-large/6/CacheHandler6_16.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_16.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_17.dn b/dat/cache/difffile-large/6/CacheHandler6_17.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_17.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_18.dn b/dat/cache/difffile-large/6/CacheHandler6_18.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_18.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_19.dn b/dat/cache/difffile-large/6/CacheHandler6_19.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_19.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_2.dn b/dat/cache/difffile-large/6/CacheHandler6_2.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_2.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_20.dn b/dat/cache/difffile-large/6/CacheHandler6_20.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_20.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_21.dn b/dat/cache/difffile-large/6/CacheHandler6_21.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_21.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_22.dn b/dat/cache/difffile-large/6/CacheHandler6_22.dn
new file mode 100644
index 0000000..3c39931
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_22.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 15/2
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_23.dn b/dat/cache/difffile-large/6/CacheHandler6_23.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_23.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_24.dn b/dat/cache/difffile-large/6/CacheHandler6_24.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_24.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_25.dn b/dat/cache/difffile-large/6/CacheHandler6_25.dn
new file mode 100644
index 0000000..7168f0c
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_25.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*4
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_26.dn b/dat/cache/difffile-large/6/CacheHandler6_26.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_26.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_27.dn b/dat/cache/difffile-large/6/CacheHandler6_27.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_27.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_28.dn b/dat/cache/difffile-large/6/CacheHandler6_28.dn
new file mode 100644
index 0000000..351e233
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_28.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_29.dn b/dat/cache/difffile-large/6/CacheHandler6_29.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_29.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_3.dn b/dat/cache/difffile-large/6/CacheHandler6_3.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_3.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_30.dn b/dat/cache/difffile-large/6/CacheHandler6_30.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_30.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_31.dn b/dat/cache/difffile-large/6/CacheHandler6_31.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_31.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_32.dn b/dat/cache/difffile-large/6/CacheHandler6_32.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_32.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_33.dn b/dat/cache/difffile-large/6/CacheHandler6_33.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_33.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_34.dn b/dat/cache/difffile-large/6/CacheHandler6_34.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_34.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_4.dn b/dat/cache/difffile-large/6/CacheHandler6_4.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_4.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_5.dn b/dat/cache/difffile-large/6/CacheHandler6_5.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_5.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_6.dn b/dat/cache/difffile-large/6/CacheHandler6_6.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_6.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_7.dn b/dat/cache/difffile-large/6/CacheHandler6_7.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_7.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_8.dn b/dat/cache/difffile-large/6/CacheHandler6_8.dn
new file mode 100644
index 0000000..cde4f6e
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_8.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/6/CacheHandler6_9.dn b/dat/cache/difffile-large/6/CacheHandler6_9.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/6/CacheHandler6_9.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_0.dn b/dat/cache/difffile-large/7/CacheHandler7_0.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_0.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_1.dn b/dat/cache/difffile-large/7/CacheHandler7_1.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_1.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_10.dn b/dat/cache/difffile-large/7/CacheHandler7_10.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_10.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_11.dn b/dat/cache/difffile-large/7/CacheHandler7_11.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_11.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_12.dn b/dat/cache/difffile-large/7/CacheHandler7_12.dn
new file mode 100644
index 0000000..cde4f6e
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_12.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_13.dn b/dat/cache/difffile-large/7/CacheHandler7_13.dn
new file mode 100644
index 0000000..2e42711
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_13.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_14.dn b/dat/cache/difffile-large/7/CacheHandler7_14.dn
new file mode 100644
index 0000000..627cd48
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_14.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 12-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_15.dn b/dat/cache/difffile-large/7/CacheHandler7_15.dn
new file mode 100644
index 0000000..4e54031
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_15.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 9-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_16.dn b/dat/cache/difffile-large/7/CacheHandler7_16.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_16.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_17.dn b/dat/cache/difffile-large/7/CacheHandler7_17.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_17.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_18.dn b/dat/cache/difffile-large/7/CacheHandler7_18.dn
new file mode 100644
index 0000000..b95d3a3
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_18.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_19.dn b/dat/cache/difffile-large/7/CacheHandler7_19.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_19.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_2.dn b/dat/cache/difffile-large/7/CacheHandler7_2.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_2.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_20.dn b/dat/cache/difffile-large/7/CacheHandler7_20.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_20.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_21.dn b/dat/cache/difffile-large/7/CacheHandler7_21.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_21.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_22.dn b/dat/cache/difffile-large/7/CacheHandler7_22.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_22.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_23.dn b/dat/cache/difffile-large/7/CacheHandler7_23.dn
new file mode 100644
index 0000000..219cc47
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_23.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_24.dn b/dat/cache/difffile-large/7/CacheHandler7_24.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_24.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_25.dn b/dat/cache/difffile-large/7/CacheHandler7_25.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_25.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_26.dn b/dat/cache/difffile-large/7/CacheHandler7_26.dn
new file mode 100644
index 0000000..7168f0c
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_26.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*4
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_27.dn b/dat/cache/difffile-large/7/CacheHandler7_27.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_27.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_28.dn b/dat/cache/difffile-large/7/CacheHandler7_28.dn
new file mode 100644
index 0000000..fd826ac
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_28.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_29.dn b/dat/cache/difffile-large/7/CacheHandler7_29.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_29.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_3.dn b/dat/cache/difffile-large/7/CacheHandler7_3.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_3.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_30.dn b/dat/cache/difffile-large/7/CacheHandler7_30.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_30.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_31.dn b/dat/cache/difffile-large/7/CacheHandler7_31.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_31.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_32.dn b/dat/cache/difffile-large/7/CacheHandler7_32.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_32.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_33.dn b/dat/cache/difffile-large/7/CacheHandler7_33.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_33.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_34.dn b/dat/cache/difffile-large/7/CacheHandler7_34.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_34.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_4.dn b/dat/cache/difffile-large/7/CacheHandler7_4.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_4.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_5.dn b/dat/cache/difffile-large/7/CacheHandler7_5.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_5.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_6.dn b/dat/cache/difffile-large/7/CacheHandler7_6.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_6.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_7.dn b/dat/cache/difffile-large/7/CacheHandler7_7.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_7.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_8.dn b/dat/cache/difffile-large/7/CacheHandler7_8.dn
new file mode 100644
index 0000000..914b79b
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_8.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/7/CacheHandler7_9.dn b/dat/cache/difffile-large/7/CacheHandler7_9.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/7/CacheHandler7_9.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_0.dn b/dat/cache/difffile-large/8/CacheHandler8_0.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_0.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_1.dn b/dat/cache/difffile-large/8/CacheHandler8_1.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_1.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_10.dn b/dat/cache/difffile-large/8/CacheHandler8_10.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_10.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_11.dn b/dat/cache/difffile-large/8/CacheHandler8_11.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_11.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_12.dn b/dat/cache/difffile-large/8/CacheHandler8_12.dn
new file mode 100644
index 0000000..914b79b
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_12.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_13.dn b/dat/cache/difffile-large/8/CacheHandler8_13.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_13.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_14.dn b/dat/cache/difffile-large/8/CacheHandler8_14.dn
new file mode 100644
index 0000000..cde4f6e
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_14.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_15.dn b/dat/cache/difffile-large/8/CacheHandler8_15.dn
new file mode 100644
index 0000000..627cd48
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_15.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 12-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_16.dn b/dat/cache/difffile-large/8/CacheHandler8_16.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_16.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_17.dn b/dat/cache/difffile-large/8/CacheHandler8_17.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_17.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_18.dn b/dat/cache/difffile-large/8/CacheHandler8_18.dn
new file mode 100644
index 0000000..b95d3a3
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_18.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_19.dn b/dat/cache/difffile-large/8/CacheHandler8_19.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_19.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_2.dn b/dat/cache/difffile-large/8/CacheHandler8_2.dn
new file mode 100644
index 0000000..2e42711
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_2.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_20.dn b/dat/cache/difffile-large/8/CacheHandler8_20.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_20.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_21.dn b/dat/cache/difffile-large/8/CacheHandler8_21.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_21.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_22.dn b/dat/cache/difffile-large/8/CacheHandler8_22.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_22.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_23.dn b/dat/cache/difffile-large/8/CacheHandler8_23.dn
new file mode 100644
index 0000000..219cc47
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_23.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_24.dn b/dat/cache/difffile-large/8/CacheHandler8_24.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_24.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_25.dn b/dat/cache/difffile-large/8/CacheHandler8_25.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_25.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_26.dn b/dat/cache/difffile-large/8/CacheHandler8_26.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_26.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_27.dn b/dat/cache/difffile-large/8/CacheHandler8_27.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_27.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_28.dn b/dat/cache/difffile-large/8/CacheHandler8_28.dn
new file mode 100644
index 0000000..fd826ac
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_28.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_29.dn b/dat/cache/difffile-large/8/CacheHandler8_29.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_29.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_3.dn b/dat/cache/difffile-large/8/CacheHandler8_3.dn
new file mode 100644
index 0000000..4e54031
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_3.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 9-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_30.dn b/dat/cache/difffile-large/8/CacheHandler8_30.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_30.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_31.dn b/dat/cache/difffile-large/8/CacheHandler8_31.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_31.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_32.dn b/dat/cache/difffile-large/8/CacheHandler8_32.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_32.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_33.dn b/dat/cache/difffile-large/8/CacheHandler8_33.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_33.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_34.dn b/dat/cache/difffile-large/8/CacheHandler8_34.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_34.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_4.dn b/dat/cache/difffile-large/8/CacheHandler8_4.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_4.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_5.dn b/dat/cache/difffile-large/8/CacheHandler8_5.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_5.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_6.dn b/dat/cache/difffile-large/8/CacheHandler8_6.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_6.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_7.dn b/dat/cache/difffile-large/8/CacheHandler8_7.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_7.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_8.dn b/dat/cache/difffile-large/8/CacheHandler8_8.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_8.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/8/CacheHandler8_9.dn b/dat/cache/difffile-large/8/CacheHandler8_9.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/8/CacheHandler8_9.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_0.dn b/dat/cache/difffile-large/9/CacheHandler9_0.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_0.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_1.dn b/dat/cache/difffile-large/9/CacheHandler9_1.dn
new file mode 100644
index 0000000..219cc47
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_1.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_10.dn b/dat/cache/difffile-large/9/CacheHandler9_10.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_10.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_11.dn b/dat/cache/difffile-large/9/CacheHandler9_11.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_11.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_12.dn b/dat/cache/difffile-large/9/CacheHandler9_12.dn
new file mode 100644
index 0000000..f8991fc
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_12.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_13.dn b/dat/cache/difffile-large/9/CacheHandler9_13.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_13.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_14.dn b/dat/cache/difffile-large/9/CacheHandler9_14.dn
new file mode 100644
index 0000000..914b79b
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_14.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_15.dn b/dat/cache/difffile-large/9/CacheHandler9_15.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_15.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_16.dn b/dat/cache/difffile-large/9/CacheHandler9_16.dn
new file mode 100644
index 0000000..cde4f6e
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_16.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_17.dn b/dat/cache/difffile-large/9/CacheHandler9_17.dn
new file mode 100644
index 0000000..627cd48
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_17.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 12-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_18.dn b/dat/cache/difffile-large/9/CacheHandler9_18.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_18.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_19.dn b/dat/cache/difffile-large/9/CacheHandler9_19.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_19.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_2.dn b/dat/cache/difffile-large/9/CacheHandler9_2.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_2.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_20.dn b/dat/cache/difffile-large/9/CacheHandler9_20.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_20.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_21.dn b/dat/cache/difffile-large/9/CacheHandler9_21.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_21.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_22.dn b/dat/cache/difffile-large/9/CacheHandler9_22.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_22.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_23.dn b/dat/cache/difffile-large/9/CacheHandler9_23.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_23.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_24.dn b/dat/cache/difffile-large/9/CacheHandler9_24.dn
new file mode 100644
index 0000000..ba9b0dc
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_24.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_25.dn b/dat/cache/difffile-large/9/CacheHandler9_25.dn
new file mode 100644
index 0000000..0726947
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_25.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0-2
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_26.dn b/dat/cache/difffile-large/9/CacheHandler9_26.dn
new file mode 100644
index 0000000..b0adee8
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_26.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_27.dn b/dat/cache/difffile-large/9/CacheHandler9_27.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_27.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_28.dn b/dat/cache/difffile-large/9/CacheHandler9_28.dn
new file mode 100644
index 0000000..fd826ac
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_28.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)-nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_29.dn b/dat/cache/difffile-large/9/CacheHandler9_29.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_29.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_3.dn b/dat/cache/difffile-large/9/CacheHandler9_3.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_3.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_30.dn b/dat/cache/difffile-large/9/CacheHandler9_30.dn
new file mode 100644
index 0000000..2e02699
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_30.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_31.dn b/dat/cache/difffile-large/9/CacheHandler9_31.dn
new file mode 100644
index 0000000..88d4397
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_31.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/random()
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_32.dn b/dat/cache/difffile-large/9/CacheHandler9_32.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_32.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_33.dn b/dat/cache/difffile-large/9/CacheHandler9_33.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_33.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_34.dn b/dat/cache/difffile-large/9/CacheHandler9_34.dn
new file mode 100644
index 0000000..ed919b2
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_34.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_4.dn b/dat/cache/difffile-large/9/CacheHandler9_4.dn
new file mode 100644
index 0000000..2e42711
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_4.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostRecentlyUsed(0)*nthMostFrequentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_5.dn b/dat/cache/difffile-large/9/CacheHandler9_5.dn
new file mode 100644
index 0000000..f70064d
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_5.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_6.dn b/dat/cache/difffile-large/9/CacheHandler9_6.dn
new file mode 100644
index 0000000..07667c8
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_6.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0+2
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_7.dn b/dat/cache/difffile-large/9/CacheHandler9_7.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_7.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_8.dn b/dat/cache/difffile-large/9/CacheHandler9_8.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_8.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/cache/difffile-large/9/CacheHandler9_9.dn b/dat/cache/difffile-large/9/CacheHandler9_9.dn
new file mode 100644
index 0000000..11e4e2d
--- /dev/null
+++ b/dat/cache/difffile-large/9/CacheHandler9_9.dn
@@ -0,0 +1,267 @@
+/*
+ *                        EmerGen(e)tic 0.8                        
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * A program to research the utility of genetic algorithms, applied to
+ * 'emergent' sytems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                            
+ * IMPROVEMENT(S): License (probably GNU GPLv3 tbh) goes here.      
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+ /**
+ **   @author  Ben Goldsworthy (rumperuu) <bgoldsworthy96 @ gmail.com>
+ **   @version 1.0
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+				index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/dat/helloworld/output0.txt b/dat/helloworld/output0.txt
new file mode 100644
index 0000000..6798a43
--- /dev/null
+++ b/dat/helloworld/output0.txt
@@ -0,0 +1,100 @@
+
+['Hello world\n', '1_0']
+['Hello world\n', '1_1']
+['Hello world\n', '1_2']
+['Hello world\n', '1_3']
+['Hello world\n', '1_4']
+['Hello world\n', '1_5']
+['Hello world\n', '1_6']
+['Hello world\n', '1_7']
+['Hello world\n', '1_8']
+['Hello world\n', '1_9']
+
+['Hello world\n', '2_0']
+['Hello world\n', '2_1']
+['Hello world\n', '2_2']
+['Hello world\n', '2_3']
+['Hello world\n', '2_4']
+['Hello world\n', '2_5']
+['Hello world\n', '2_6']
+['Hello world\n', '2_7']
+['Hello world\n', '2_8']
+['Hello world\n', '2_9']
+
+['Hello world\n', '3_0']
+['Hello world\n', '3_1']
+['Hello world\n', '3_2']
+['Hello world\n', '3_3']
+['Hello world\n', '3_4']
+['Hello world\n', '3_5']
+['Hello world\n', '3_6']
+['Hello world\n', '3_7']
+['Hello world\n', '3_8']
+['Hello world\n', '3_9']
+
+['Hello world\n', '4_0']
+['Hello world\n', '4_1']
+['Hello world\n', '4_2']
+['Hello world\n', '4_3']
+['Hello world\n', '4_4']
+['Hello world\n', '4_5']
+['Hello world\n', '4_6']
+['Hello world\n', '4_7']
+['Hello world\n', '4_8']
+['Hello world\n', '4_9']
+
+['Hello world\n', '5_0']
+['Hello world\n', '5_1']
+['Hello world\n', '5_2']
+['Hello world\n', '5_3']
+['Hello world\n', '5_4']
+['Hello world\n', '5_5']
+['Hello world\n', '5_6']
+['Hello world\n', '5_7']
+['Hello world\n', '5_8']
+['Hello world\n', '5_9']
+
+['Hello world\n', '6_0']
+['Hello world\n', '6_1']
+['Hello world\n', '6_2']
+['Hello world\n', '6_3']
+['Hello world\n', '6_4']
+['Hello world\n', '6_5']
+['Hello world\n', '6_6']
+['Hello world\n', '6_7']
+['Hello world\n', '6_8']
+['Hello world\n', '6_9']
+
+['Hello world\n', '7_0']
+['Hello world\n', '7_1']
+['Hello world\n', '7_2']
+['Hello world\n', '7_3']
+['Hello world\n', '7_4']
+['Hello world\n', '7_5']
+['Hello world\n', '7_6']
+['Hello world\n', '7_7']
+['Hello world\n', '7_8']
+['Hello world\n', '7_9']
+
+['Hello world\n', '8_0']
+['Hello world\n', '8_1']
+['Hello world\n', '8_2']
+['Hello world\n', '8_3']
+['Hello world\n', '8_4']
+['Hello world\n', '8_5']
+['Hello world\n', '8_6']
+['Hello world\n', '8_7']
+['Hello world\n', '8_8']
+['Hello world\n', '8_9']
+
+['Hello world\n', '9_0']
+['Hello world\n', '9_1']
+['Hello world\n', '9_2']
+['Hello world\n', '9_3']
+['Hello world\n', '9_4']
+['Hello world\n', '9_5']
+['Hello world\n', '9_6']
+['Hello world\n', '9_7']
+['Hello world\n', '9_8']
+['Hello world\n', '9_9']
+
diff --git a/dat/helloworld/output100.txt b/dat/helloworld/output100.txt
new file mode 100644
index 0000000..f9c05cb
--- /dev/null
+++ b/dat/helloworld/output100.txt
@@ -0,0 +1,100 @@
+
+['ampcjlcutjs', '1_0']
+['xktieosrnyx', '1_1']
+['caxedgtiyup', '1_2']
+['cqyiujnyapp', '1_3']
+['wnkwuyamxxz', '1_4']
+['rfotmkuheyv', '1_5']
+['eveudzvxhzj', '1_6']
+['ftgxinfdomw', '1_7']
+['mdjomfeoggy', '1_8']
+['fibdllxjmox', '1_9']
+
+['pwfumdlcauk', '2_0']
+['bfoxwhovtgm', '2_1']
+['gqpztkejijs', '2_2']
+['drxavuclcka', '2_3']
+['wiycvultuli', '2_4']
+['uyxeayumsdc', '2_5']
+['mubbtclbees', '2_6']
+['xezoaznywmq', '2_7']
+['mjlcdtnuekd', '2_8']
+['cdzklmlaayk', '2_9']
+
+['dwsvoawkono', '3_0']
+['vokazvphity', '3_1']
+['ogxdqkpodqt', '3_2']
+['rogfabbqmdn', '3_3']
+['ygtasskorjq', '3_4']
+['obpgipyogbm', '3_5']
+['mtpiqcignyk', '3_6']
+['bnzugplaclt', '3_7']
+['dekckrrqqrz', '3_8']
+['jxdbtdrzbka', '3_9']
+
+['zeyofehsgel', '4_0']
+['unqpqfgncqq', '4_1']
+['vyirphbzqnv', '4_2']
+['enpjablprua', '4_3']
+['gvnikmusunw', '4_4']
+['bviefpdtdje', '4_5']
+['qogzptxbnsv', '4_6']
+['hjdvmrnewsj', '4_7']
+['kqdetdhygmq', '4_8']
+['xmxqnnwvdxq', '4_9']
+
+['oyvocjrkmik', '5_0']
+['ugfnrykhfmr', '5_1']
+['xsqhoxiaduh', '5_2']
+['gkmwhksxzkt', '5_3']
+['rusllvvfgww', '5_4']
+['ozelqmixipj', '5_5']
+['ilmjpwedmrk', '5_6']
+['aptysrjsjkw', '5_7']
+['fmklqkskknf', '5_8']
+['yzekmmmuvul', '5_9']
+
+['bitequtywek', '6_0']
+['iqlvnjtermm', '6_1']
+['bvahdtxyrep', '6_2']
+['skxqhsirryo', '6_3']
+['ajoexxutuhd', '6_4']
+['umwormhnxlz', '6_5']
+['htvrrhqgvzl', '6_6']
+['pzitdowgnjg', '6_7']
+['aikbtvejkvr', '6_8']
+['rxttpdhjteo', '6_9']
+
+['bghnmmqxksh', '7_0']
+['eqxbhukjhkk', '7_1']
+['pjsplpilhpa', '7_2']
+['fepbzvhjxyd', '7_3']
+['brycqntqkgi', '7_4']
+['ybmnzzqkjbm', '7_5']
+['yovrjairprl', '7_6']
+['lqgfoqrtbhy', '7_7']
+['iwqvaeoyteb', '7_8']
+['cidgqfwqzjm', '7_9']
+
+['qcjqmcerknt', '8_0']
+['prziehtdtey', '8_1']
+['oimlyxwgrke', '8_2']
+['nhesujrxtmw', '8_3']
+['vvkbmiupaxk', '8_4']
+['hzvigxvglsh', '8_5']
+['qbvjkftsngc', '8_6']
+['hqkqxkwqnph', '8_7']
+['vafgdyouzia', '8_8']
+['tcdxmxvmzgs', '8_9']
+
+['eojplmnbdca', '9_0']
+['bxibnaghyjd', '9_1']
+['wbcjmozsszm', '9_2']
+['bsavrzfzuyp', '9_3']
+['kktmgrnajpc', '9_4']
+['gvrsehcxdkq', '9_5']
+['djgcialnryd', '9_6']
+['dvuwcklknlt', '9_7']
+['hoaxsvpmibw', '9_8']
+['oetzcsckiyu', '9_9']
+
diff --git a/dat/helloworld/output50.txt b/dat/helloworld/output50.txt
new file mode 100644
index 0000000..253b8c0
--- /dev/null
+++ b/dat/helloworld/output50.txt
@@ -0,0 +1,100 @@
+
+['Hello world\n', '1_0']
+['Hello world\n', '1_1']
+['Hello world\n', '1_2']
+['Hekjo joaky', '1_3']
+['Hello world\n', '1_4']
+['hiblm wokly', '1_5']
+['Hello world\n', '1_6']
+['Hello world\n', '1_7']
+['Hello world\n', '1_8']
+['yeclo wdvld', '1_9']
+
+['jmdlo warld', '2_0']
+['Hello wtrld', '2_1']
+['lejlodyowld', '2_2']
+['ijllordokld', '2_3']
+['Htlloikocsd', '2_4']
+['vvkqo wnrzi', '2_5']
+['Hygro wrplf', '2_6']
+['Hello world\n', '2_7']
+['Hellr zxrld', '2_8']
+['tehzy wordd', '2_9']
+
+['Hqslo wokad', '3_0']
+['yexerzsorlh', '3_1']
+['lejlodyowld', '3_2']
+['dtvblxworld', '3_3']
+['gelro qorqd', '3_4']
+['vvkqo wnrzi', '3_5']
+['mmlty wxsjd', '3_6']
+['Hello world\n', '3_7']
+['Hellr zxrld', '3_8']
+['tehzy wordd', '3_9']
+
+['Hello wonlm', '4_0']
+['ftllo wwalj', '4_1']
+['lejlodyowld', '4_2']
+['Hezun woiue', '4_3']
+['Hqmlo woyir', '4_4']
+['vvkqo wnrzi', '4_5']
+['mmlty wxsjd', '4_6']
+['Hglyo wveld', '4_7']
+['Hellr zxrld', '4_8']
+['meugm wjrlz', '4_9']
+
+['Hauln wouyd', '5_0']
+['ftllo wwalj', '5_1']
+['lejlodyowld', '5_2']
+['Hezun woiue', '5_3']
+['Heplo wcrld', '5_4']
+['vvkqo wnrzi', '5_5']
+['qello worfd', '5_6']
+['Hglyo wveld', '5_7']
+['Hlulowwdglj', '5_8']
+['meugm wjrlz', '5_9']
+
+['zvumo varqc', '6_0']
+['zvlgo uorlw', '6_1']
+['Hulle woslb', '6_2']
+['Hello wtxid', '6_3']
+['Heplo wcrld', '6_4']
+['vvkqo wnrzi', '6_5']
+['qello worfd', '6_6']
+['Hglyo wveld', '6_7']
+['Hlulowwdglj', '6_8']
+['meugm wjrlz', '6_9']
+
+['zvumo varqc', '7_0']
+['Hzlyowwowld', '7_1']
+['Hulle woslb', '7_2']
+['Hnlroemorvc', '7_3']
+['Heltlroorld', '7_4']
+['vvkqo wnrzi', '7_5']
+['peylqxwprnr', '7_6']
+['Hglyo wveld', '7_7']
+['telah zzrod', '7_8']
+['meugm wjrlz', '7_9']
+
+['iealouporfy', '8_0']
+['Hzlyowwowld', '8_1']
+['Hulle woslb', '8_2']
+['Hnlroemorvc', '8_3']
+['hezbxgworcd', '8_4']
+['vvkqo wnrzi', '8_5']
+['peylqxwprnr', '8_6']
+['Hglyo wveld', '8_7']
+['thjlh wyhld', '8_8']
+['meugm wjrlz', '8_9']
+
+['iealouporfy', '9_0']
+['Hzlyowwowld', '9_1']
+['Hulle woslb', '9_2']
+['Hesho uovms', '9_3']
+['Hehcq forxd', '9_4']
+['vvkqo wnrzi', '9_5']
+['Hrllniwonld', '9_6']
+['Hrjmo wlrkd', '9_7']
+['lehoncworld', '9_8']
+['qejloywztod', '9_9']
+
diff --git a/dat/output (normal).txt b/dat/output (normal).txt
new file mode 100644
index 0000000..f266bfd
--- /dev/null
+++ b/dat/output (normal).txt	
@@ -0,0 +1,648 @@
+
+Result for configuration 0x0: 63 ms
+Result for configuration 0x1: 21 ms
+Result for configuration 0x2: 21 ms
+Result for configuration 0x3: 20 ms
+Result for configuration 0x4: 21 ms
+Result for configuration 0x5: 20 ms
+Result for configuration 0x6: 21 ms
+Result for configuration 0x7: 21 ms
+Result for configuration 0x8: 21 ms
+Result for configuration 0x9: 21 ms
+Result for configuration 0x10: 20 ms
+Result for configuration 0x11: 21 ms
+Result for configuration 0x12: 21 ms
+Result for configuration 0x13: 20 ms
+Result for configuration 0x14: 21 ms
+Result for configuration 0x15: 20 ms
+Result for configuration 0x16: 21 ms
+Result for configuration 0x17: 21 ms
+Result for configuration 0x18: 21 ms
+Result for configuration 0x19: 21 ms
+Result for configuration 0x20: 21 ms
+Result for configuration 0x21: 21 ms
+Result for configuration 0x22: 21 ms
+Result for configuration 0x23: 21 ms
+Result for configuration 0x24: 21 ms
+Result for configuration 0x25: 21 ms
+Result for configuration 0x26: 21 ms
+Result for configuration 0x27: 20 ms
+Result for configuration 0x28: 21 ms
+Result for configuration 0x29: 21 ms
+Result for configuration 0x30: 20 ms
+Result for configuration 0x31: 21 ms
+Result for configuration 0x32: 21 ms
+Result for configuration 0x33: 21 ms
+Result for configuration 0x34: 21 ms
+
+Result for configuration 1x0: 21 ms
+Result for configuration 1x1: 21 ms
+Result for configuration 1x2: 21 ms
+Result for configuration 1x3: 21 ms
+Result for configuration 1x4: 21 ms
+Result for configuration 1x5: 21 ms
+Result for configuration 1x6: 20 ms
+Result for configuration 1x7: 21 ms
+Result for configuration 1x8: 21 ms
+Result for configuration 1x9: 21 ms
+Result for configuration 1x10: 21 ms
+Result for configuration 1x11: 20 ms
+Result for configuration 1x12: 21 ms
+Result for configuration 1x13: 21 ms
+Result for configuration 1x14: 21 ms
+Result for configuration 1x15: 21 ms
+Result for configuration 1x16: 21 ms
+Result for configuration 1x17: 21 ms
+Result for configuration 1x18: 21 ms
+Result for configuration 1x19: 21 ms
+Result for configuration 1x20: 20 ms
+Result for configuration 1x21: 21 ms
+Result for configuration 1x22: 21 ms
+Result for configuration 1x23: 21 ms
+Result for configuration 1x24: 21 ms
+Result for configuration 1x25: 21 ms
+Result for configuration 1x26: 21 ms
+Result for configuration 1x27: 21 ms
+Result for configuration 1x28: 21 ms
+Result for configuration 1x29: 21 ms
+Result for configuration 1x30: 21 ms
+Result for configuration 1x31: 21 ms
+Result for configuration 1x32: 21 ms
+Result for configuration 1x33: 21 ms
+Result for configuration 1x34: 20 ms
+
+Result for configuration 2x0: 21 ms
+Result for configuration 2x1: 21 ms
+Result for configuration 2x2: 21 ms
+Result for configuration 2x3: 21 ms
+Result for configuration 2x4: 20 ms
+Result for configuration 2x5: 21 ms
+Result for configuration 2x6: 21 ms
+Result for configuration 2x7: 21 ms
+Result for configuration 2x8: 21 ms
+Result for configuration 2x9: 21 ms
+Result for configuration 2x10: 21 ms
+Result for configuration 2x11: 21 ms
+Result for configuration 2x12: 21 ms
+Result for configuration 2x13: 21 ms
+Result for configuration 2x14: 21 ms
+Result for configuration 2x15: 21 ms
+Result for configuration 2x16: 21 ms
+Result for configuration 2x17: 21 ms
+Result for configuration 2x18: 21 ms
+Result for configuration 2x19: 21 ms
+Result for configuration 2x20: 22 ms
+Result for configuration 2x21: 21 ms
+Result for configuration 2x22: 20 ms
+Result for configuration 2x23: 20 ms
+Result for configuration 2x24: 21 ms
+Result for configuration 2x25: 21 ms
+Result for configuration 2x26: 21 ms
+Result for configuration 2x27: 20 ms
+Result for configuration 2x28: 21 ms
+Result for configuration 2x29: 21 ms
+Result for configuration 2x30: 21 ms
+Result for configuration 2x31: 21 ms
+Result for configuration 2x32: 21 ms
+Result for configuration 2x33: 20 ms
+Result for configuration 2x34: 21 ms
+
+Result for configuration 3x0: 22 ms
+Result for configuration 3x1: 21 ms
+Result for configuration 3x2: 21 ms
+Result for configuration 3x3: 21 ms
+Result for configuration 3x4: 21 ms
+Result for configuration 3x5: 21 ms
+Result for configuration 3x6: 21 ms
+Result for configuration 3x7: 20 ms
+Result for configuration 3x8: 21 ms
+Result for configuration 3x9: 21 ms
+Result for configuration 3x10: 21 ms
+Result for configuration 3x11: 21 ms
+Result for configuration 3x12: 21 ms
+Result for configuration 3x13: 20 ms
+Result for configuration 3x14: 21 ms
+Result for configuration 3x15: 21 ms
+Result for configuration 3x16: 21 ms
+Result for configuration 3x17: 21 ms
+Result for configuration 3x18: 21 ms
+Result for configuration 3x19: 20 ms
+Result for configuration 3x20: 21 ms
+Result for configuration 3x21: 21 ms
+Result for configuration 3x22: 20 ms
+Result for configuration 3x23: 21 ms
+Result for configuration 3x24: 21 ms
+Result for configuration 3x25: 21 ms
+Result for configuration 3x26: 20 ms
+Result for configuration 3x27: 21 ms
+Result for configuration 3x28: 20 ms
+Result for configuration 3x29: 21 ms
+Result for configuration 3x30: 21 ms
+Result for configuration 3x31: 21 ms
+Result for configuration 3x32: 21 ms
+Result for configuration 3x33: 22 ms
+Result for configuration 3x34: 21 ms
+
+Result for configuration 4x0: 21 ms
+Result for configuration 4x1: 22 ms
+Result for configuration 4x2: 21 ms
+Result for configuration 4x3: 22 ms
+Result for configuration 4x4: 21 ms
+Result for configuration 4x5: 21 ms
+Result for configuration 4x6: 21 ms
+Result for configuration 4x7: 21 ms
+Result for configuration 4x8: 21 ms
+Result for configuration 4x9: 21 ms
+Result for configuration 4x10: 21 ms
+Result for configuration 4x11: 21 ms
+Result for configuration 4x12: 21 ms
+Result for configuration 4x13: 20 ms
+Result for configuration 4x14: 21 ms
+Result for configuration 4x15: 21 ms
+Result for configuration 4x16: 21 ms
+Result for configuration 4x17: 21 ms
+Result for configuration 4x18: 21 ms
+Result for configuration 4x19: 21 ms
+Result for configuration 4x20: 21 ms
+Result for configuration 4x21: 20 ms
+Result for configuration 4x22: 20 ms
+Result for configuration 4x23: 21 ms
+Result for configuration 4x24: 21 ms
+Result for configuration 4x25: 21 ms
+Result for configuration 4x26: 21 ms
+Result for configuration 4x27: 21 ms
+Result for configuration 4x28: 21 ms
+Result for configuration 4x29: 20 ms
+Result for configuration 4x30: 21 ms
+Result for configuration 4x31: 21 ms
+Result for configuration 4x32: 22 ms
+Result for configuration 4x33: 21 ms
+Result for configuration 4x34: 21 ms
+
+Result for configuration 5x0: 21 ms
+Result for configuration 5x1: 22 ms
+Result for configuration 5x2: 22 ms
+Result for configuration 5x3: 21 ms
+Result for configuration 5x4: 21 ms
+Result for configuration 5x5: 21 ms
+Result for configuration 5x6: 21 ms
+Result for configuration 5x7: 20 ms
+Result for configuration 5x8: 21 ms
+Result for configuration 5x9: 21 ms
+Result for configuration 5x10: 21 ms
+Result for configuration 5x11: 20 ms
+Result for configuration 5x12: 21 ms
+Result for configuration 5x13: 21 ms
+Result for configuration 5x14: 21 ms
+Result for configuration 5x15: 21 ms
+Result for configuration 5x16: 20 ms
+Result for configuration 5x17: 21 ms
+Result for configuration 5x18: 20 ms
+Result for configuration 5x19: 20 ms
+Result for configuration 5x20: 20 ms
+Result for configuration 5x21: 21 ms
+Result for configuration 5x22: 20 ms
+Result for configuration 5x23: 21 ms
+Result for configuration 5x24: 21 ms
+Result for configuration 5x25: 21 ms
+Result for configuration 5x26: 21 ms
+Result for configuration 5x27: 20 ms
+Result for configuration 5x28: 21 ms
+Result for configuration 5x29: 20 ms
+Result for configuration 5x30: 21 ms
+Result for configuration 5x31: 21 ms
+Result for configuration 5x32: 21 ms
+Result for configuration 5x33: 21 ms
+Result for configuration 5x34: 21 ms
+
+Result for configuration 6x0: 21 ms
+Result for configuration 6x1: 21 ms
+Result for configuration 6x2: 21 ms
+Result for configuration 6x3: 21 ms
+Result for configuration 6x4: 21 ms
+Result for configuration 6x5: 21 ms
+Result for configuration 6x6: 21 ms
+Result for configuration 6x7: 21 ms
+Result for configuration 6x8: 22 ms
+Result for configuration 6x9: 20 ms
+Result for configuration 6x10: 21 ms
+Result for configuration 6x11: 21 ms
+Result for configuration 6x12: 21 ms
+Result for configuration 6x13: 22 ms
+Result for configuration 6x14: 21 ms
+Result for configuration 6x15: 21 ms
+Result for configuration 6x16: 21 ms
+Result for configuration 6x17: 21 ms
+Result for configuration 6x18: 21 ms
+Result for configuration 6x19: 21 ms
+Result for configuration 6x20: 21 ms
+Result for configuration 6x21: 20 ms
+Result for configuration 6x22: 21 ms
+Result for configuration 6x23: 20 ms
+Result for configuration 6x24: 21 ms
+Result for configuration 6x25: 21 ms
+Result for configuration 6x26: 21 ms
+Result for configuration 6x27: 20 ms
+Result for configuration 6x28: 21 ms
+Result for configuration 6x29: 21 ms
+Result for configuration 6x30: 21 ms
+Result for configuration 6x31: 21 ms
+Result for configuration 6x32: 21 ms
+Result for configuration 6x33: 21 ms
+Result for configuration 6x34: 21 ms
+
+Result for configuration 7x0: 22 ms
+Result for configuration 7x1: 22 ms
+Result for configuration 7x2: 21 ms
+Result for configuration 7x3: 22 ms
+Result for configuration 7x4: 22 ms
+Result for configuration 7x5: 21 ms
+Result for configuration 7x6: 21 ms
+Result for configuration 7x7: 21 ms
+Result for configuration 7x8: 21 ms
+Result for configuration 7x9: 20 ms
+Result for configuration 7x10: 20 ms
+Result for configuration 7x11: 21 ms
+Result for configuration 7x12: 21 ms
+Result for configuration 7x13: 20 ms
+Result for configuration 7x14: 21 ms
+Result for configuration 7x15: 20 ms
+Result for configuration 7x16: 21 ms
+Result for configuration 7x17: 20 ms
+Result for configuration 7x18: 21 ms
+Result for configuration 7x19: 21 ms
+Result for configuration 7x20: 21 ms
+Result for configuration 7x21: 21 ms
+Result for configuration 7x22: 21 ms
+Result for configuration 7x23: 20 ms
+Result for configuration 7x24: 21 ms
+Result for configuration 7x25: 21 ms
+Result for configuration 7x26: 21 ms
+Result for configuration 7x27: 20 ms
+Result for configuration 7x28: 21 ms
+Result for configuration 7x29: 21 ms
+Result for configuration 7x30: 21 ms
+Result for configuration 7x31: 21 ms
+Result for configuration 7x32: 21 ms
+Result for configuration 7x33: 21 ms
+Result for configuration 7x34: 21 ms
+
+Result for configuration 8x0: 21 ms
+Result for configuration 8x1: 21 ms
+Result for configuration 8x2: 21 ms
+Result for configuration 8x3: 21 ms
+Result for configuration 8x4: 21 ms
+Result for configuration 8x5: 21 ms
+Result for configuration 8x6: 22 ms
+Result for configuration 8x7: 22 ms
+Result for configuration 8x8: 21 ms
+Result for configuration 8x9: 21 ms
+Result for configuration 8x10: 21 ms
+Result for configuration 8x11: 21 ms
+Result for configuration 8x12: 21 ms
+Result for configuration 8x13: 21 ms
+Result for configuration 8x14: 21 ms
+Result for configuration 8x15: 21 ms
+Result for configuration 8x16: 20 ms
+Result for configuration 8x17: 21 ms
+Result for configuration 8x18: 21 ms
+Result for configuration 8x19: 22 ms
+Result for configuration 8x20: 21 ms
+Result for configuration 8x21: 21 ms
+Result for configuration 8x22: 21 ms
+Result for configuration 8x23: 20 ms
+Result for configuration 8x24: 21 ms
+Result for configuration 8x25: 21 ms
+Result for configuration 8x26: 21 ms
+Result for configuration 8x27: 21 ms
+Result for configuration 8x28: 21 ms
+Result for configuration 8x29: 21 ms
+Result for configuration 8x30: 21 ms
+Result for configuration 8x31: 21 ms
+Result for configuration 8x32: 21 ms
+Result for configuration 8x33: 21 ms
+Result for configuration 8x34: 21 ms
+
+Result for configuration 9x0: 22 ms
+Result for configuration 9x1: 21 ms
+Result for configuration 9x2: 21 ms
+Result for configuration 9x3: 21 ms
+Result for configuration 9x4: 21 ms
+Result for configuration 9x5: 21 ms
+Result for configuration 9x6: 21 ms
+Result for configuration 9x7: 21 ms
+Result for configuration 9x8: 21 ms
+Result for configuration 9x9: 21 ms
+Result for configuration 9x10: 21 ms
+Result for configuration 9x11: 21 ms
+Result for configuration 9x12: 21 ms
+Result for configuration 9x13: 21 ms
+Result for configuration 9x14: 21 ms
+Result for configuration 9x15: 21 ms
+Result for configuration 9x16: 21 ms
+Result for configuration 9x17: 21 ms
+Result for configuration 9x18: 21 ms
+Result for configuration 9x19: 20 ms
+Result for configuration 9x20: 21 ms
+Result for configuration 9x21: 21 ms
+Result for configuration 9x22: 21 ms
+Result for configuration 9x23: 21 ms
+Result for configuration 9x24: 21 ms
+Result for configuration 9x25: 21 ms
+Result for configuration 9x26: 20 ms
+Result for configuration 9x27: 21 ms
+Result for configuration 9x28: 21 ms
+Result for configuration 9x29: 21 ms
+Result for configuration 9x30: 21 ms
+Result for configuration 9x31: 21 ms
+Result for configuration 9x32: 21 ms
+Result for configuration 9x33: 21 ms
+Result for configuration 9x34: 21 ms
+
+Result for configuration 10x0: 22 ms
+Result for configuration 10x1: 22 ms
+Result for configuration 10x2: 22 ms
+Result for configuration 10x3: 21 ms
+Result for configuration 10x4: 21 ms
+Result for configuration 10x5: 22 ms
+Result for configuration 10x6: 22 ms
+Result for configuration 10x7: 21 ms
+Result for configuration 10x8: 21 ms
+Result for configuration 10x9: 21 ms
+Result for configuration 10x10: 21 ms
+Result for configuration 10x11: 20 ms
+Result for configuration 10x12: 22 ms
+Result for configuration 10x13: 22 ms
+Result for configuration 10x14: 21 ms
+Result for configuration 10x15: 21 ms
+Result for configuration 10x16: 21 ms
+Result for configuration 10x17: 21 ms
+Result for configuration 10x18: 21 ms
+Result for configuration 10x19: 20 ms
+Result for configuration 10x20: 21 ms
+Result for configuration 10x21: 21 ms
+Result for configuration 10x22: 21 ms
+Result for configuration 10x23: 21 ms
+Result for configuration 10x24: 20 ms
+Result for configuration 10x25: 20 ms
+Result for configuration 10x26: 21 ms
+Result for configuration 10x27: 21 ms
+Result for configuration 10x28: 21 ms
+Result for configuration 10x29: 21 ms
+Result for configuration 10x30: 21 ms
+Result for configuration 10x31: 21 ms
+Result for configuration 10x32: 21 ms
+Result for configuration 10x33: 21 ms
+Result for configuration 10x34: 21 ms
+
+Result for configuration 11x0: 21 ms
+Result for configuration 11x1: 21 ms
+Result for configuration 11x2: 22 ms
+Result for configuration 11x3: 21 ms
+Result for configuration 11x4: 22 ms
+Result for configuration 11x5: 22 ms
+Result for configuration 11x6: 21 ms
+Result for configuration 11x7: 22 ms
+Result for configuration 11x8: 21 ms
+Result for configuration 11x9: 21 ms
+Result for configuration 11x10: 21 ms
+Result for configuration 11x11: 21 ms
+Result for configuration 11x12: 21 ms
+Result for configuration 11x13: 21 ms
+Result for configuration 11x14: 22 ms
+Result for configuration 11x15: 21 ms
+Result for configuration 11x16: 22 ms
+Result for configuration 11x17: 21 ms
+Result for configuration 11x18: 21 ms
+Result for configuration 11x19: 22 ms
+Result for configuration 11x20: 21 ms
+Result for configuration 11x21: 21 ms
+Result for configuration 11x22: 21 ms
+Result for configuration 11x23: 21 ms
+Result for configuration 11x24: 20 ms
+Result for configuration 11x25: 21 ms
+Result for configuration 11x26: 21 ms
+Result for configuration 11x27: 21 ms
+Result for configuration 11x28: 21 ms
+Result for configuration 11x29: 21 ms
+Result for configuration 11x30: 21 ms
+Result for configuration 11x31: 21 ms
+Result for configuration 11x32: 21 ms
+Result for configuration 11x33: 21 ms
+Result for configuration 11x34: 21 ms
+
+Result for configuration 12x0: 22 ms
+Result for configuration 12x1: 21 ms
+Result for configuration 12x2: 22 ms
+Result for configuration 12x3: 21 ms
+Result for configuration 12x4: 21 ms
+Result for configuration 12x5: 22 ms
+Result for configuration 12x6: 21 ms
+Result for configuration 12x7: 21 ms
+Result for configuration 12x8: 21 ms
+Result for configuration 12x9: 21 ms
+Result for configuration 12x10: 21 ms
+Result for configuration 12x11: 22 ms
+Result for configuration 12x12: 21 ms
+Result for configuration 12x13: 22 ms
+Result for configuration 12x14: 20 ms
+Result for configuration 12x15: 21 ms
+Result for configuration 12x16: 21 ms
+Result for configuration 12x17: 21 ms
+Result for configuration 12x18: 21 ms
+Result for configuration 12x19: 21 ms
+Result for configuration 12x20: 21 ms
+Result for configuration 12x21: 21 ms
+Result for configuration 12x22: 21 ms
+Result for configuration 12x23: 21 ms
+Result for configuration 12x24: 20 ms
+Result for configuration 12x25: 21 ms
+Result for configuration 12x26: 22 ms
+Result for configuration 12x27: 21 ms
+Result for configuration 12x28: 21 ms
+Result for configuration 12x29: 20 ms
+Result for configuration 12x30: 20 ms
+Result for configuration 12x31: 21 ms
+Result for configuration 12x32: 21 ms
+Result for configuration 12x33: 21 ms
+Result for configuration 12x34: 21 ms
+
+Result for configuration 13x0: 22 ms
+Result for configuration 13x1: 22 ms
+Result for configuration 13x2: 22 ms
+Result for configuration 13x3: 21 ms
+Result for configuration 13x4: 21 ms
+Result for configuration 13x5: 22 ms
+Result for configuration 13x6: 22 ms
+Result for configuration 13x7: 21 ms
+Result for configuration 13x8: 21 ms
+Result for configuration 13x9: 22 ms
+Result for configuration 13x10: 21 ms
+Result for configuration 13x11: 21 ms
+Result for configuration 13x12: 21 ms
+Result for configuration 13x13: 21 ms
+Result for configuration 13x14: 21 ms
+Result for configuration 13x15: 21 ms
+Result for configuration 13x16: 21 ms
+Result for configuration 13x17: 21 ms
+Result for configuration 13x18: 21 ms
+Result for configuration 13x19: 21 ms
+Result for configuration 13x20: 21 ms
+Result for configuration 13x21: 20 ms
+Result for configuration 13x22: 21 ms
+Result for configuration 13x23: 21 ms
+Result for configuration 13x24: 21 ms
+Result for configuration 13x25: 21 ms
+Result for configuration 13x26: 21 ms
+Result for configuration 13x27: 21 ms
+Result for configuration 13x28: 21 ms
+Result for configuration 13x29: 21 ms
+Result for configuration 13x30: 21 ms
+Result for configuration 13x31: 21 ms
+Result for configuration 13x32: 20 ms
+Result for configuration 13x33: 21 ms
+Result for configuration 13x34: 21 ms
+
+Result for configuration 14x0: 22 ms
+Result for configuration 14x1: 21 ms
+Result for configuration 14x2: 22 ms
+Result for configuration 14x3: 21 ms
+Result for configuration 14x4: 21 ms
+Result for configuration 14x5: 21 ms
+Result for configuration 14x6: 22 ms
+Result for configuration 14x7: 21 ms
+Result for configuration 14x8: 21 ms
+Result for configuration 14x9: 21 ms
+Result for configuration 14x10: 21 ms
+Result for configuration 14x11: 21 ms
+Result for configuration 14x12: 21 ms
+Result for configuration 14x13: 21 ms
+Result for configuration 14x14: 21 ms
+Result for configuration 14x15: 21 ms
+Result for configuration 14x16: 21 ms
+Result for configuration 14x17: 21 ms
+Result for configuration 14x18: 20 ms
+Result for configuration 14x19: 20 ms
+Result for configuration 14x20: 21 ms
+Result for configuration 14x21: 21 ms
+Result for configuration 14x22: 21 ms
+Result for configuration 14x23: 21 ms
+Result for configuration 14x24: 21 ms
+Result for configuration 14x25: 21 ms
+Result for configuration 14x26: 21 ms
+Result for configuration 14x27: 21 ms
+Result for configuration 14x28: 21 ms
+Result for configuration 14x29: 21 ms
+Result for configuration 14x30: 21 ms
+Result for configuration 14x31: 21 ms
+Result for configuration 14x32: 21 ms
+Result for configuration 14x33: 20 ms
+Result for configuration 14x34: 22 ms
+
+Result for configuration 15x0: 22 ms
+Result for configuration 15x1: 22 ms
+Result for configuration 15x2: 21 ms
+Result for configuration 15x3: 21 ms
+Result for configuration 15x4: 21 ms
+Result for configuration 15x5: 21 ms
+Result for configuration 15x6: 21 ms
+Result for configuration 15x7: 22 ms
+Result for configuration 15x8: 21 ms
+Result for configuration 15x9: 22 ms
+Result for configuration 15x10: 22 ms
+Result for configuration 15x11: 22 ms
+Result for configuration 15x12: 21 ms
+Result for configuration 15x13: 21 ms
+Result for configuration 15x14: 21 ms
+Result for configuration 15x15: 21 ms
+Result for configuration 15x16: 21 ms
+Result for configuration 15x17: 21 ms
+Result for configuration 15x18: 21 ms
+Result for configuration 15x19: 21 ms
+Result for configuration 15x20: 21 ms
+Result for configuration 15x21: 21 ms
+Result for configuration 15x22: 21 ms
+Result for configuration 15x23: 21 ms
+Result for configuration 15x24: 21 ms
+Result for configuration 15x25: 21 ms
+Result for configuration 15x26: 21 ms
+Result for configuration 15x27: 21 ms
+Result for configuration 15x28: 20 ms
+Result for configuration 15x29: 21 ms
+Result for configuration 15x30: 21 ms
+Result for configuration 15x31: 21 ms
+Result for configuration 15x32: 21 ms
+Result for configuration 15x33: 21 ms
+Result for configuration 15x34: 21 ms
+
+Result for configuration 16x0: 21 ms
+Result for configuration 16x1: 22 ms
+Result for configuration 16x2: 21 ms
+Result for configuration 16x3: 22 ms
+Result for configuration 16x4: 22 ms
+Result for configuration 16x5: 21 ms
+Result for configuration 16x6: 21 ms
+Result for configuration 16x7: 21 ms
+Result for configuration 16x8: 21 ms
+Result for configuration 16x9: 22 ms
+Result for configuration 16x10: 21 ms
+Result for configuration 16x11: 22 ms
+Result for configuration 16x12: 22 ms
+Result for configuration 16x13: 21 ms
+Result for configuration 16x14: 21 ms
+Result for configuration 16x15: 22 ms
+Result for configuration 16x16: 22 ms
+Result for configuration 16x17: 21 ms
+Result for configuration 16x18: 21 ms
+Result for configuration 16x19: 21 ms
+Result for configuration 16x20: 21 ms
+Result for configuration 16x21: 21 ms
+Result for configuration 16x22: 21 ms
+Result for configuration 16x23: 21 ms
+Result for configuration 16x24: 21 ms
+Result for configuration 16x25: 21 ms
+Result for configuration 16x26: 22 ms
+Result for configuration 16x27: 21 ms
+Result for configuration 16x28: 21 ms
+Result for configuration 16x29: 21 ms
+Result for configuration 16x30: 21 ms
+Result for configuration 16x31: 21 ms
+Result for configuration 16x32: 21 ms
+Result for configuration 16x33: 21 ms
+Result for configuration 16x34: 21 ms
+
+Result for configuration 17x0: 21 ms
+Result for configuration 17x1: 21 ms
+Result for configuration 17x2: 21 ms
+Result for configuration 17x3: 22 ms
+Result for configuration 17x4: 21 ms
+Result for configuration 17x5: 22 ms
+Result for configuration 17x6: 21 ms
+Result for configuration 17x7: 21 ms
+Result for configuration 17x8: 21 ms
+Result for configuration 17x9: 22 ms
+Result for configuration 17x10: 21 ms
+Result for configuration 17x11: 21 ms
+Result for configuration 17x12: 21 ms
+Result for configuration 17x13: 21 ms
+Result for configuration 17x14: 21 ms
+Result for configuration 17x15: 22 ms
+Result for configuration 17x16: 21 ms
+Result for configuration 17x17: 22 ms
+Result for configuration 17x18: 22 ms
+Result for configuration 17x19: 21 ms
+Result for configuration 17x20: 21 ms
+Result for configuration 17x21: 21 ms
+Result for configuration 17x22: 20 ms
+Result for configuration 17x23: 21 ms
+Result for configuration 17x24: 21 ms
+Result for configuration 17x25: 21 ms
+Result for configuration 17x26: 21 ms
+Result for configuration 17x27: 21 ms
+Result for configuration 17x28: 21 ms
+Result for configuration 17x29: 21 ms
+Result for configuration 17x30: 21 ms
+Result for configuration 17x31: 21 ms
+Result for configuration 17x32: 21 ms
+Result for configuration 17x33: 21 ms
+Result for configuration 17x34: 20 ms
diff --git a/dat/output (verbose).txt b/dat/output (verbose).txt
new file mode 100644
index 0000000..3837ca2
--- /dev/null
+++ b/dat/output (verbose).txt	
@@ -0,0 +1,1027 @@
+Result for configuration 0x0: 21 ms
+Result for configuration 0x1: 21 ms
+Result for configuration 0x2: 21 ms
+Result for configuration 0x3: 21 ms
+Result for configuration 0x4: 21 ms
+Result for configuration 0x5: 21 ms
+Result for configuration 0x6: 21 ms
+Result for configuration 0x7: 20 ms
+Result for configuration 0x8: 21 ms
+Result for configuration 0x9: 21 ms
+Result for configuration 0x10: 21 ms
+Result for configuration 0x11: 21 ms
+Result for configuration 0x12: 21 ms
+Result for configuration 0x13: 20 ms
+Result for configuration 0x14: 21 ms
+Result for configuration 0x15: 21 ms
+Result for configuration 0x16: 21 ms
+Result for configuration 0x17: 21 ms
+Result for configuration 0x18: 20 ms
+Result for configuration 0x19: 21 ms
+Result for configuration 0x20: 20 ms
+Result for configuration 0x21: 20 ms
+Result for configuration 0x22: 21 ms
+Result for configuration 0x23: 21 ms
+Result for configuration 0x24: 21 ms
+Result for configuration 0x25: 20 ms
+Result for configuration 0x26: 21 ms
+Result for configuration 0x27: 20 ms
+Result for configuration 0x28: 20 ms
+Result for configuration 0x29: 21 ms
+Result for configuration 0x30: 21 ms
+Result for configuration 0x31: 21 ms
+Result for configuration 0x32: 21 ms
+Result for configuration 0x33: 21 ms
+Result for configuration 0x34: 21 ms
+
+Applying rank selection to top 10% from prev. generation...
+	Result: 0_3 copied to 1_3
+	Result: 0_5 copied to 1_5
+	Result: 0_10 copied to 1_10
+	Result: 0_13 copied to 1_13
+
+
+Mutating 0_6->1_6:
+	Mutating: 0
+		Result: 0/13
+	Mutating: 0/13
+		Result: 0+13
+	Mutating: 0+13
+		Result: 0+18
+0_6->1_6 mutation finish.
+
+Mutating 0_7->1_7:
+	Mutating: 0
+		Result: 0*12
+	Mutating: 0*12
+		Result: 0*12
+	Mutating: 0*12
+		Result: 0*nthMostRecentlyUsed(0)
+0_7->1_7 mutation finish.
+
+Mutating 0_19->1_19:
+	Mutating: 0
+		Result: 0
+0_19->1_19 mutation finish.
+
+Mutating 0_21->1_21:
+	Mutating: 0
+		Result: 0*17
+	Mutating: 0*17
+		Result: 0-17
+	Mutating: 0-17
+		Result: 0-nthMostFrequentlyUsed(0)
+0_21->1_21 mutation finish.
+
+Mutating 0_25->1_25:
+	Mutating: 0
+		Result: 0
+0_25->1_25 mutation finish.
+
+Mutating 0_27->1_27:
+	Mutating: 0
+		Result: 0
+0_27->1_27 mutation finish.
+
+Mutating 0_28->1_28:
+	Mutating: 0
+		Result: 0
+0_28->1_28 mutation finish.
+
+
+Result for configuration 1x0: 21 ms
+Result for configuration 1x1: 20 ms
+Result for configuration 1x2: 22 ms
+Result for configuration 1x3: 22 ms
+Result for configuration 1x4: 21 ms
+Result for configuration 1x5: 21 ms
+Result for configuration 1x6: 21 ms
+Result for configuration 1x7: 21 ms
+Result for configuration 1x8: 21 ms
+Result for configuration 1x9: 21 ms
+Result for configuration 1x10: 20 ms
+Result for configuration 1x11: 21 ms
+Result for configuration 1x12: 21 ms
+Result for configuration 1x13: 21 ms
+Result for configuration 1x14: 20 ms
+Result for configuration 1x15: 21 ms
+Result for configuration 1x16: 21 ms
+Result for configuration 1x17: 21 ms
+Result for configuration 1x18: 21 ms
+Result for configuration 1x19: 21 ms
+Result for configuration 1x20: 21 ms
+Result for configuration 1x21: 21 ms
+Result for configuration 1x22: 21 ms
+Result for configuration 1x23: 22 ms
+Result for configuration 1x24: 21 ms
+Result for configuration 1x25: 21 ms
+Result for configuration 1x26: 21 ms
+Result for configuration 1x27: 21 ms
+Result for configuration 1x28: 21 ms
+Result for configuration 1x29: 20 ms
+Result for configuration 1x30: 20 ms
+Result for configuration 1x31: 21 ms
+Result for configuration 1x32: 20 ms
+Result for configuration 1x33: 21 ms
+Result for configuration 1x34: 21 ms
+
+Applying rank selection to top 10% from prev. generation...
+	Result: 1_6 copied to 2_6
+	Result: 1_11 copied to 2_11
+	Result: 1_20 copied to 2_20
+	Result: 1_34 copied to 2_34
+
+
+Mutating 1_1->2_1:
+	Mutating: 0
+		Result: 0
+1_1->2_1 mutation finish.
+
+Mutating 1_14->2_14:
+	Mutating: 0
+		Result: 0*13
+	Mutating: 0*13
+		Result: 0*13
+	Mutating: 0*13
+		Result: 0*19
+1_14->2_14 mutation finish.
+
+Mutating 1_15->2_15:
+	Mutating: 0
+		Result: 0
+1_15->2_15 mutation finish.
+
+Mutating 1_18->2_18:
+	Mutating: 0
+		Result: 0*16
+	Mutating: 0*16
+		Result: 0/16
+	Mutating: 0/16
+		Result: 0/3
+1_18->2_18 mutation finish.
+
+Mutating 1_21->2_21:
+	Mutating: 0-nthMostFrequentlyUsed(0)
+		Result: 5-nthMostFrequentlyUsed(0)
+	Mutating: 5-nthMostFrequentlyUsed(0)
+		Result: 5-nthMostFrequentlyUsed(0)
+	Mutating: 5-nthMostFrequentlyUsed(0)
+		Result: 5-nthMostFrequentlyUsed(0)
+	Mutating: 5-nthMostFrequentlyUsed(0)
+		Result: 5-nthMostFrequentlyUsed(0)
+1_21->2_21 mutation finish.
+
+Mutating 1_23->2_23:
+	Mutating: 0
+		Result: 0+11
+	Mutating: 0+11
+		Result: 0-11
+	Mutating: 0-11
+		Result: 0-nthMostFrequentlyUsed(0)
+1_23->2_23 mutation finish.
+
+Mutating 1_25->2_25:
+	Mutating: 0
+		Result: 0/3
+	Mutating: 0/3
+		Result: 0/3
+	Mutating: 0/3
+		Result: 0/nthMostRecentlyUsed(0)
+1_25->2_25 mutation finish.
+
+Mutating 1_27->2_27:
+	Mutating: 0
+		Result: 0*9
+	Mutating: 0*9
+		Result: 0/9
+	Mutating: 0/9
+		Result: 0/3
+1_27->2_27 mutation finish.
+
+
+Result for configuration 2x0: 21 ms
+Result for configuration 2x1: 21 ms
+Result for configuration 2x2: 20 ms
+Result for configuration 2x3: 21 ms
+Result for configuration 2x4: 20 ms
+Result for configuration 2x5: 21 ms
+Result for configuration 2x6: 20 ms
+Result for configuration 2x7: 22 ms
+Result for configuration 2x8: 22 ms
+Result for configuration 2x9: 21 ms
+Result for configuration 2x10: 21 ms
+Result for configuration 2x11: 22 ms
+Result for configuration 2x12: 21 ms
+Result for configuration 2x13: 21 ms
+Result for configuration 2x14: 21 ms
+Result for configuration 2x15: 21 ms
+Result for configuration 2x16: 21 ms
+Result for configuration 2x17: 21 ms
+Result for configuration 2x18: 20 ms
+Result for configuration 2x19: 21 ms
+Result for configuration 2x20: 21 ms
+Result for configuration 2x21: 20 ms
+Result for configuration 2x22: 21 ms
+Result for configuration 2x23: 21 ms
+Result for configuration 2x24: 21 ms
+Result for configuration 2x25: 21 ms
+Result for configuration 2x26: 21 ms
+Result for configuration 2x27: 21 ms
+Result for configuration 2x28: 21 ms
+Result for configuration 2x29: 21 ms
+Result for configuration 2x30: 21 ms
+Result for configuration 2x31: 20 ms
+Result for configuration 2x32: 21 ms
+Result for configuration 2x33: 21 ms
+Result for configuration 2x34: 21 ms
+
+Applying rank selection to top 10% from prev. generation...
+	Result: 2_4 copied to 3_4
+	Result: 2_22 copied to 3_22
+	Result: 2_23 copied to 3_23
+	Result: 2_27 copied to 3_27
+
+
+Mutating 2_6->3_6:
+	Mutating: 0
+		Result: 0+1
+	Mutating: 0+1
+		Result: 0+1
+	Mutating: 0+1
+		Result: 0+random()
+2_6->3_6 mutation finish.
+
+Mutating 2_12->3_12:
+	Mutating: 0*nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+2_12->3_12 mutation finish.
+
+Mutating 2_16->3_16:
+	Mutating: 0*19
+		Result: nthMostRecentlyUsed(0)*19
+	Mutating: nthMostRecentlyUsed(0)*19
+		Result: nthMostRecentlyUsed(0)-19
+	Mutating: nthMostRecentlyUsed(0)-19
+		Result: nthMostRecentlyUsed(0)-9
+2_16->3_16 mutation finish.
+
+Mutating 2_19->3_19:
+	Mutating: 0
+		Result: 0
+2_19->3_19 mutation finish.
+
+Mutating 2_20->3_20:
+	Mutating: 0/3
+		Result: nthMostFrequentlyUsed(0)/3
+	Mutating: nthMostFrequentlyUsed(0)/3
+		Result: nthMostFrequentlyUsed(0)+3
+	Mutating: nthMostFrequentlyUsed(0)+3
+		Result: nthMostFrequentlyUsed(0)+2
+2_20->3_20 mutation finish.
+
+Mutating 2_21->3_21:
+	Mutating: 0
+		Result: 0+19
+	Mutating: 0+19
+		Result: 0*19
+	Mutating: 0*19
+		Result: 0*nthMostRecentlyUsed(0)
+2_21->3_21 mutation finish.
+
+Mutating 2_31->3_31:
+	Mutating: 0
+		Result: 0/2
+	Mutating: 0/2
+		Result: 0+2
+	Mutating: 0+2
+		Result: 0+nthMostRecentlyUsed(0)
+2_31->3_31 mutation finish.
+
+Mutating 2_32->3_32:
+	Mutating: 0
+		Result: 0
+2_32->3_32 mutation finish.
+
+Mutating 2_33->3_33:
+	Mutating: 0
+		Result: 0
+2_33->3_33 mutation finish.
+
+
+Result for configuration 3x0: 22 ms
+Result for configuration 3x1: 21 ms
+Result for configuration 3x2: 21 ms
+Result for configuration 3x3: 20 ms
+Result for configuration 3x4: 22 ms
+Result for configuration 3x5: 21 ms
+Result for configuration 3x6: 21 ms
+Result for configuration 3x7: 21 ms
+Result for configuration 3x8: 20 ms
+Result for configuration 3x9: 21 ms
+Result for configuration 3x10: 21 ms
+Result for configuration 3x11: 20 ms
+Result for configuration 3x12: 21 ms
+Result for configuration 3x13: 20 ms
+Result for configuration 3x14: 20 ms
+Result for configuration 3x15: 21 ms
+Result for configuration 3x16: 20 ms
+Result for configuration 3x17: 21 ms
+Result for configuration 3x18: 20 ms
+Result for configuration 3x19: 20 ms
+Result for configuration 3x20: 21 ms
+Result for configuration 3x21: 20 ms
+Result for configuration 3x22: 21 ms
+Result for configuration 3x23: 21 ms
+Result for configuration 3x24: 21 ms
+Result for configuration 3x25: 21 ms
+Result for configuration 3x26: 21 ms
+Result for configuration 3x27: 21 ms
+Result for configuration 3x28: 21 ms
+Result for configuration 3x29: 21 ms
+Result for configuration 3x30: 21 ms
+Result for configuration 3x31: 20 ms
+Result for configuration 3x32: 20 ms
+Result for configuration 3x33: 21 ms
+Result for configuration 3x34: 21 ms
+
+Applying rank selection to top 10% from prev. generation...
+	Result: 3_7 copied to 4_7
+	Result: 3_13 copied to 4_13
+	Result: 3_19 copied to 4_19
+	Result: 3_22 copied to 4_22
+
+
+Mutating 3_15->4_15:
+	Mutating: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+3_15->4_15 mutation finish.
+
+Mutating 3_18->4_18:
+	Mutating: 0
+		Result: 0+12
+	Mutating: 0+12
+		Result: 0+12
+	Mutating: 0+12
+		Result: 0+nthMostRecentlyUsed(0)
+3_18->4_18 mutation finish.
+
+Mutating 3_26->4_26:
+	Mutating: 0
+		Result: 0/8
+	Mutating: 0/8
+		Result: 0/8
+	Mutating: 0/8
+		Result: 0/nthMostRecentlyUsed(0)
+3_26->4_26 mutation finish.
+
+Mutating 3_32->4_32:
+	Mutating: 0
+		Result: 0-3
+	Mutating: 0-3
+		Result: 0-3
+	Mutating: 0-3
+		Result: 0-nthMostRecentlyUsed(0)
+3_32->4_32 mutation finish.
+
+
+Result for configuration 4x0: 21 ms
+Result for configuration 4x1: 21 ms
+Result for configuration 4x2: 21 ms
+Result for configuration 4x3: 21 ms
+Result for configuration 4x4: 21 ms
+Result for configuration 4x5: 20 ms
+Result for configuration 4x6: 21 ms
+Result for configuration 4x7: 21 ms
+Result for configuration 4x8: 21 ms
+Result for configuration 4x9: 21 ms
+Result for configuration 4x10: 21 ms
+Result for configuration 4x11: 21 ms
+Result for configuration 4x12: 21 ms
+Result for configuration 4x13: 20 ms
+Result for configuration 4x14: 21 ms
+Result for configuration 4x15: 20 ms
+Result for configuration 4x16: 20 ms
+Result for configuration 4x17: 21 ms
+Result for configuration 4x18: 21 ms
+Result for configuration 4x19: 20 ms
+Result for configuration 4x20: 21 ms
+Result for configuration 4x21: 21 ms
+Result for configuration 4x22: 20 ms
+Result for configuration 4x23: 21 ms
+Result for configuration 4x24: 21 ms
+Result for configuration 4x25: 20 ms
+Result for configuration 4x26: 21 ms
+Result for configuration 4x27: 21 ms
+Result for configuration 4x28: 20 ms
+Result for configuration 4x29: 21 ms
+Result for configuration 4x30: 21 ms
+Result for configuration 4x31: 20 ms
+Result for configuration 4x32: 21 ms
+Result for configuration 4x33: 21 ms
+Result for configuration 4x34: 21 ms
+
+Applying rank selection to top 10% from prev. generation...
+	Result: 4_13 copied to 5_13
+	Result: 4_21 copied to 5_21
+	Result: 4_22 copied to 5_22
+	Result: 4_29 copied to 5_29
+
+
+Mutating 4_2->5_2:
+	Mutating: nthMostRecentlyUsed(0)-9
+		Result: nthMostRecentlyUsed(0)-9
+	Mutating: nthMostRecentlyUsed(0)-9
+		Result: nthMostRecentlyUsed(0)-9
+	Mutating: nthMostRecentlyUsed(0)-9
+		Result: nthMostRecentlyUsed(0)-9
+	Mutating: nthMostRecentlyUsed(0)-9
+		Result: nthMostRecentlyUsed(0)-nthMostRecentlyUsed(0)
+4_2->5_2 mutation finish.
+
+Mutating 4_8->5_8:
+	Mutating: 0
+		Result: 0/11
+	Mutating: 0/11
+		Result: 0/11
+	Mutating: 0/11
+		Result: 0/nthMostRecentlyUsed(0)
+4_8->5_8 mutation finish.
+
+Mutating 4_9->5_9:
+	Mutating: 0
+		Result: 0
+4_9->5_9 mutation finish.
+
+Mutating 4_12->5_12:
+	Mutating: 0+random()
+		Result: nthMostFrequentlyUsed(0)+random()
+	Mutating: nthMostFrequentlyUsed(0)+random()
+		Result: nthMostFrequentlyUsed(0)/random()
+	Mutating: nthMostFrequentlyUsed(0)/random()
+		Result: nthMostFrequentlyUsed(0)/random()
+4_12->5_12 mutation finish.
+
+Mutating 4_20->5_20:
+	Mutating: 0+nthMostRecentlyUsed(0)
+		Result: nthMostFrequentlyUsed(0)+nthMostRecentlyUsed(0)
+	Mutating: nthMostFrequentlyUsed(0)+nthMostRecentlyUsed(0)
+		Result: nthMostFrequentlyUsed(0)*nthMostRecentlyUsed(0)
+	Mutating: nthMostFrequentlyUsed(0)*nthMostRecentlyUsed(0)
+		Result: nthMostFrequentlyUsed(0)*nthMostRecentlyUsed(0)
+	Mutating: nthMostFrequentlyUsed(0)*nthMostRecentlyUsed(0)
+		Result: nthMostFrequentlyUsed(0)*nthMostRecentlyUsed(0)
+4_20->5_20 mutation finish.
+
+Mutating 4_34->5_34:
+	Mutating: 0
+		Result: 0/5
+	Mutating: 0/5
+		Result: 0+5
+	Mutating: 0+5
+		Result: 0+nthMostRecentlyUsed(0)
+4_34->5_34 mutation finish.
+
+
+Result for configuration 5x0: 21 ms
+Result for configuration 5x1: 22 ms
+Result for configuration 5x2: 21 ms
+Result for configuration 5x3: 22 ms
+Result for configuration 5x4: 21 ms
+Result for configuration 5x5: 20 ms
+Result for configuration 5x6: 20 ms
+Result for configuration 5x7: 21 ms
+Result for configuration 5x8: 20 ms
+Result for configuration 5x9: 20 ms
+Result for configuration 5x10: 21 ms
+Result for configuration 5x11: 22 ms
+Result for configuration 5x12: 21 ms
+Result for configuration 5x13: 21 ms
+Result for configuration 5x14: 21 ms
+Result for configuration 5x15: 20 ms
+Result for configuration 5x16: 21 ms
+Result for configuration 5x17: 20 ms
+Result for configuration 5x18: 21 ms
+Result for configuration 5x19: 21 ms
+Result for configuration 5x20: 21 ms
+Result for configuration 5x21: 21 ms
+Result for configuration 5x22: 21 ms
+Result for configuration 5x23: 21 ms
+Result for configuration 5x24: 21 ms
+Result for configuration 5x25: 21 ms
+Result for configuration 5x26: 20 ms
+Result for configuration 5x27: 20 ms
+Result for configuration 5x28: 21 ms
+Result for configuration 5x29: 21 ms
+Result for configuration 5x30: 20 ms
+Result for configuration 5x31: 20 ms
+Result for configuration 5x32: 21 ms
+Result for configuration 5x33: 21 ms
+Result for configuration 5x34: 21 ms
+
+Applying rank selection to top 10% from prev. generation...
+	Result: 5_7 copied to 6_7
+	Result: 5_11 copied to 6_11
+	Result: 5_16 copied to 6_16
+	Result: 5_18 copied to 6_18
+
+
+Mutating 5_0->6_0:
+	Mutating: 0
+		Result: 0/9
+	Mutating: 0/9
+		Result: 0/9
+	Mutating: 0/9
+		Result: 0/nthMostRecentlyUsed(0)
+5_0->6_0 mutation finish.
+
+Mutating 5_8->6_8:
+	Mutating: 0
+		Result: 0
+5_8->6_8 mutation finish.
+
+Mutating 5_30->6_30:
+	Mutating: 0
+		Result: 0-16
+	Mutating: 0-16
+		Result: 0+16
+	Mutating: 0+16
+		Result: 0+nthMostFrequentlyUsed(0)
+5_30->6_30 mutation finish.
+
+
+Result for configuration 6x0: 21 ms
+Result for configuration 6x1: 21 ms
+Result for configuration 6x2: 21 ms
+Result for configuration 6x3: 21 ms
+Result for configuration 6x4: 21 ms
+Result for configuration 6x5: 21 ms
+Result for configuration 6x6: 21 ms
+Result for configuration 6x7: 20 ms
+Result for configuration 6x8: 21 ms
+Result for configuration 6x9: 20 ms
+Result for configuration 6x10: 21 ms
+Result for configuration 6x11: 21 ms
+Result for configuration 6x12: 21 ms
+Result for configuration 6x13: 20 ms
+Result for configuration 6x14: 21 ms
+Result for configuration 6x15: 21 ms
+Result for configuration 6x16: 21 ms
+Result for configuration 6x17: 20 ms
+Result for configuration 6x18: 21 ms
+Result for configuration 6x19: 21 ms
+Result for configuration 6x20: 21 ms
+Result for configuration 6x21: 21 ms
+Result for configuration 6x22: 21 ms
+Result for configuration 6x23: 21 ms
+Result for configuration 6x24: 21 ms
+Result for configuration 6x25: 21 ms
+Result for configuration 6x26: 21 ms
+Result for configuration 6x27: 20 ms
+Result for configuration 6x28: 21 ms
+Result for configuration 6x29: 20 ms
+Result for configuration 6x30: 20 ms
+Result for configuration 6x31: 21 ms
+Result for configuration 6x32: 20 ms
+Result for configuration 6x33: 20 ms
+Result for configuration 6x34: 21 ms
+
+Applying rank selection to top 10% from prev. generation...
+	Result: 6_9 copied to 7_9
+	Result: 6_21 copied to 7_21
+	Result: 6_23 copied to 7_23
+	Result: 6_27 copied to 7_27
+
+
+Mutating 6_20->7_20:
+	Mutating: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)*nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+6_20->7_20 mutation finish.
+
+Mutating 6_22->7_22:
+	Mutating: 0
+		Result: 0/8
+	Mutating: 0/8
+		Result: 0/8
+	Mutating: 0/8
+		Result: 0/nthMostFrequentlyUsed(0)
+6_22->7_22 mutation finish.
+
+Mutating 6_26->7_26:
+	Mutating: 0-nthMostFrequentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+6_26->7_26 mutation finish.
+
+
+Result for configuration 7x0: 21 ms
+Result for configuration 7x1: 21 ms
+Result for configuration 7x2: 21 ms
+Result for configuration 7x3: 21 ms
+Result for configuration 7x4: 21 ms
+Result for configuration 7x5: 22 ms
+Result for configuration 7x6: 21 ms
+Result for configuration 7x7: 21 ms
+Result for configuration 7x8: 21 ms
+Result for configuration 7x9: 21 ms
+Result for configuration 7x10: 21 ms
+Result for configuration 7x11: 20 ms
+Result for configuration 7x12: 21 ms
+Result for configuration 7x13: 21 ms
+Result for configuration 7x14: 21 ms
+Result for configuration 7x15: 21 ms
+Result for configuration 7x16: 21 ms
+Result for configuration 7x17: 21 ms
+Result for configuration 7x18: 21 ms
+Result for configuration 7x19: 20 ms
+Result for configuration 7x20: 21 ms
+Result for configuration 7x21: 21 ms
+Result for configuration 7x22: 20 ms
+Result for configuration 7x23: 21 ms
+Result for configuration 7x24: 21 ms
+Result for configuration 7x25: 21 ms
+Result for configuration 7x26: 21 ms
+Result for configuration 7x27: 20 ms
+Result for configuration 7x28: 21 ms
+Result for configuration 7x29: 20 ms
+Result for configuration 7x30: 21 ms
+Result for configuration 7x31: 21 ms
+Result for configuration 7x32: 21 ms
+Result for configuration 7x33: 21 ms
+Result for configuration 7x34: 21 ms
+
+Applying rank selection to top 10% from prev. generation...
+	Result: 7_9 copied to 8_9
+	Result: 7_10 copied to 8_10
+	Result: 7_13 copied to 8_13
+	Result: 7_15 copied to 8_15
+
+
+Mutating 7_1->8_1:
+	Mutating: 0
+		Result: 0
+7_1->8_1 mutation finish.
+
+Mutating 7_6->8_6:
+	Mutating: nthMostFrequentlyUsed(0)/random()
+		Result: nthMostFrequentlyUsed(0)/random()
+	Mutating: nthMostFrequentlyUsed(0)/random()
+		Result: nthMostFrequentlyUsed(0)/random()
+	Mutating: nthMostFrequentlyUsed(0)/random()
+		Result: nthMostFrequentlyUsed(0)/random()
+	Mutating: nthMostFrequentlyUsed(0)/random()
+		Result: nthMostFrequentlyUsed(0)/random()
+7_6->8_6 mutation finish.
+
+Mutating 7_12->8_12:
+	Mutating: 0
+		Result: 0
+7_12->8_12 mutation finish.
+
+Mutating 7_27->8_27:
+	Mutating: nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)-nthMostFrequentlyUsed(0)
+7_27->8_27 mutation finish.
+
+Mutating 7_28->8_28:
+	Mutating: 0/nthMostRecentlyUsed(0)
+		Result: 9/nthMostRecentlyUsed(0)
+	Mutating: 9/nthMostRecentlyUsed(0)
+		Result: 9/nthMostRecentlyUsed(0)
+	Mutating: 9/nthMostRecentlyUsed(0)
+		Result: 9/nthMostRecentlyUsed(0)
+	Mutating: 9/nthMostRecentlyUsed(0)
+		Result: 9/nthMostRecentlyUsed(0)
+7_28->8_28 mutation finish.
+
+
+Result for configuration 8x0: 21 ms
+Result for configuration 8x1: 21 ms
+Result for configuration 8x2: 21 ms
+Result for configuration 8x3: 21 ms
+Result for configuration 8x4: 21 ms
+Result for configuration 8x5: 21 ms
+Result for configuration 8x6: 21 ms
+Result for configuration 8x7: 22 ms
+Result for configuration 8x8: 21 ms
+Result for configuration 8x9: 20 ms
+Result for configuration 8x10: 21 ms
+Result for configuration 8x11: 21 ms
+Result for configuration 8x12: 21 ms
+Result for configuration 8x13: 21 ms
+Result for configuration 8x14: 22 ms
+Result for configuration 8x15: 21 ms
+Result for configuration 8x16: 21 ms
+Result for configuration 8x17: 20 ms
+Result for configuration 8x18: 21 ms
+Result for configuration 8x19: 21 ms
+Result for configuration 8x20: 21 ms
+Result for configuration 8x21: 21 ms
+Result for configuration 8x22: 21 ms
+Result for configuration 8x23: 20 ms
+Result for configuration 8x24: 21 ms
+Result for configuration 8x25: 21 ms
+Result for configuration 8x26: 21 ms
+Result for configuration 8x27: 21 ms
+Result for configuration 8x28: 21 ms
+Result for configuration 8x29: 20 ms
+Result for configuration 8x30: 21 ms
+Result for configuration 8x31: 21 ms
+Result for configuration 8x32: 21 ms
+Result for configuration 8x33: 21 ms
+Result for configuration 8x34: 21 ms
+
+Applying rank selection to top 10% from prev. generation...
+	Result: 8_16 copied to 9_16
+	Result: 8_23 copied to 9_23
+	Result: 8_9 copied to 9_9
+	Result: 8_17 copied to 9_17
+
+
+Mutating 8_14->9_14:
+	Mutating: 0
+		Result: 0-5
+	Mutating: 0-5
+		Result: 0-5
+	Mutating: 0-5
+		Result: 0-8
+8_14->9_14 mutation finish.
+
+Mutating 8_15->9_15:
+	Mutating: 0
+		Result: 0/9
+	Mutating: 0/9
+		Result: 0/9
+	Mutating: 0/9
+		Result: 0/6
+8_15->9_15 mutation finish.
+
+Mutating 8_31->9_31:
+	Mutating: 0+nthMostRecentlyUsed(0)
+		Result: 3+nthMostRecentlyUsed(0)
+	Mutating: 3+nthMostRecentlyUsed(0)
+		Result: 3/nthMostRecentlyUsed(0)
+	Mutating: 3/nthMostRecentlyUsed(0)
+		Result: 3/nthMostRecentlyUsed(0)
+	Mutating: 3/nthMostRecentlyUsed(0)
+		Result: 3/nthMostRecentlyUsed(0)
+8_31->9_31 mutation finish.
+
+Mutating 8_34->9_34:
+	Mutating: 0+nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)+nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)+nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+8_34->9_34 mutation finish.
+
+
+Result for configuration 9x0: 21 ms
+Result for configuration 9x1: 21 ms
+Result for configuration 9x2: 21 ms
+Result for configuration 9x3: 21 ms
+Result for configuration 9x4: 21 ms
+Result for configuration 9x5: 21 ms
+Result for configuration 9x6: 22 ms
+Result for configuration 9x7: 22 ms
+Result for configuration 9x8: 21 ms
+Result for configuration 9x9: 21 ms
+Result for configuration 9x10: 21 ms
+Result for configuration 9x11: 21 ms
+Result for configuration 9x12: 21 ms
+Result for configuration 9x13: 20 ms
+Result for configuration 9x14: 20 ms
+Result for configuration 9x15: 21 ms
+Result for configuration 9x16: 20 ms
+Result for configuration 9x17: 21 ms
+Result for configuration 9x18: 20 ms
+Result for configuration 9x19: 21 ms
+Result for configuration 9x20: 21 ms
+Result for configuration 9x21: 20 ms
+Result for configuration 9x22: 21 ms
+Result for configuration 9x23: 21 ms
+Result for configuration 9x24: 21 ms
+Result for configuration 9x25: 21 ms
+Result for configuration 9x26: 20 ms
+Result for configuration 9x27: 21 ms
+Result for configuration 9x28: 21 ms
+Result for configuration 9x29: 21 ms
+Result for configuration 9x30: 20 ms
+Result for configuration 9x31: 20 ms
+Result for configuration 9x32: 21 ms
+Result for configuration 9x33: 21 ms
+Result for configuration 9x34: 20 ms
+
+Applying rank selection to top 10% from prev. generation...
+	Result: 9_19 copied to 10_19
+	Result: 9_26 copied to 10_26
+	Result: 9_13 copied to 10_13
+	Result: 9_14 copied to 10_14
+
+
+Mutating 9_4->10_4:
+	Mutating: 0
+		Result: 0/14
+	Mutating: 0/14
+		Result: 0/14
+	Mutating: 0/14
+		Result: 0/nthMostRecentlyUsed(0)
+9_4->10_4 mutation finish.
+
+Mutating 9_12->10_12:
+	Mutating: 0
+		Result: 0
+9_12->10_12 mutation finish.
+
+Mutating 9_31->10_31:
+	Mutating: 3/nthMostRecentlyUsed(0)
+		Result: nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+	Mutating: nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+		Result: nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+	Mutating: nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+		Result: nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+	Mutating: nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+		Result: nthMostFrequentlyUsed(0)/nthMostRecentlyUsed(0)
+9_31->10_31 mutation finish.
+
+Mutating 9_34->10_34:
+	Mutating: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+9_34->10_34 mutation finish.
+
+
+Result for configuration 10x0: 21 ms
+Result for configuration 10x1: 21 ms
+Result for configuration 10x2: 21 ms
+Result for configuration 10x3: 21 ms
+Result for configuration 10x4: 21 ms
+Result for configuration 10x5: 21 ms
+Result for configuration 10x6: 21 ms
+Result for configuration 10x7: 21 ms
+Result for configuration 10x8: 21 ms
+Result for configuration 10x9: 21 ms
+Result for configuration 10x10: 20 ms
+Result for configuration 10x11: 21 ms
+Result for configuration 10x12: 21 ms
+Result for configuration 10x13: 21 ms
+Result for configuration 10x14: 21 ms
+Result for configuration 10x15: 20 ms
+Result for configuration 10x16: 21 ms
+Result for configuration 10x17: 21 ms
+Result for configuration 10x18: 21 ms
+Result for configuration 10x19: 21 ms
+Result for configuration 10x20: 20 ms
+Result for configuration 10x21: 21 ms
+Result for configuration 10x22: 21 ms
+Result for configuration 10x23: 21 ms
+Result for configuration 10x24: 21 ms
+Result for configuration 10x25: 20 ms
+Result for configuration 10x26: 20 ms
+Result for configuration 10x27: 21 ms
+Result for configuration 10x28: 21 ms
+Result for configuration 10x29: 21 ms
+Result for configuration 10x30: 21 ms
+Result for configuration 10x31: 21 ms
+Result for configuration 10x32: 21 ms
+Result for configuration 10x33: 20 ms
+Result for configuration 10x34: 21 ms
+
+Applying rank selection to top 10% from prev. generation...
+	Result: 10_11 copied to 11_11
+	Result: 10_19 copied to 11_19
+	Result: 10_24 copied to 11_24
+	Result: 10_25 copied to 11_25
+
+
+Mutating 10_8->11_8:
+	Mutating: 0/nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+10_8->11_8 mutation finish.
+
+Mutating 10_20->11_20:
+	Mutating: 0/6
+		Result: nthMostRecentlyUsed(0)/6
+	Mutating: nthMostRecentlyUsed(0)/6
+		Result: nthMostRecentlyUsed(0)+6
+	Mutating: nthMostRecentlyUsed(0)+6
+		Result: nthMostRecentlyUsed(0)+nthMostFrequentlyUsed(0)
+10_20->11_20 mutation finish.
+
+Mutating 10_26->11_26:
+	Mutating: nthMostFrequentlyUsed(0)+2
+		Result: nthMostFrequentlyUsed(0)+2
+	Mutating: nthMostFrequentlyUsed(0)+2
+		Result: nthMostFrequentlyUsed(0)+2
+	Mutating: nthMostFrequentlyUsed(0)+2
+		Result: nthMostFrequentlyUsed(0)+2
+	Mutating: nthMostFrequentlyUsed(0)+2
+		Result: nthMostFrequentlyUsed(0)+17
+10_26->11_26 mutation finish.
+
+Mutating 10_28->11_28:
+	Mutating: 9/nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+	Mutating: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+		Result: nthMostRecentlyUsed(0)/nthMostRecentlyUsed(0)
+10_28->11_28 mutation finish.
+
+Mutating 10_33->11_33:
+	Mutating: 0
+		Result: 0-18
+	Mutating: 0-18
+		Result: 0-18
+	Mutating: 0-18
+		Result: 0-nthMostRecentlyUsed(0)
+10_33->11_33 mutation finish.
+
+
+Result for configuration 11x0: 22 ms
+Result for configuration 11x1: 21 ms
+Result for configuration 11x2: 21 ms
+Result for configuration 11x3: 21 ms
+Result for configuration 11x4: 21 ms
+Result for configuration 11x5: 21 ms
+Result for configuration 11x6: 21 ms
+Result for configuration 11x7: 21 ms
+Result for configuration 11x8: 21 ms
+Result for configuration 11x9: 21 ms
+Result for configuration 11x10: 21 ms
+Result for configuration 11x11: 21 ms
+Result for configuration 11x12: 21 ms
+Result for configuration 11x13: 21 ms
+Result for configuration 11x14: 21 ms
+Result for configuration 11x15: 21 ms
+Result for configuration 11x16: 20 ms
+Result for configuration 11x17: 20 ms
+Result for configuration 11x18: 21 ms
+Result for configuration 11x19: 20 ms
+Result for configuration 11x20: 20 ms
+Result for configuration 11x21: 21 ms
+Result for configuration 11x22: 21 ms
+Result for configuration 11x23: 21 ms
+Result for configuration 11x24: 21 ms
+Result for configuration 11x25: 20 ms
+Result for configuration 11x26: 21 ms
+Result for configuration 11x27: 21 ms
+Result for configuration 11x28: 21 ms
+Result for configuration 11x29: 21 ms
+Result for configuration 11x30: 21 ms
+Result for configuration 11x31: 20 ms
+Result for configuration 11x32: 20 ms
+Result for configuration 11x33: 20 ms
+Result for configuration 11x34: 21 ms
diff --git a/dat/results/results_difffile-large.ods b/dat/results/results_difffile-large.ods
new file mode 100644
index 0000000..513f2c8
Binary files /dev/null and b/dat/results/results_difffile-large.ods differ
diff --git a/dat/results/results_samefile-images.ods b/dat/results/results_samefile-images.ods
new file mode 100644
index 0000000..235cfc6
Binary files /dev/null and b/dat/results/results_samefile-images.ods differ
diff --git a/dat/runTests.sh b/dat/runTests.sh
new file mode 100644
index 0000000..25ed1ab
--- /dev/null
+++ b/dat/runTests.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+# Runs Emergen(e)tic with a series of scripts
+
+GEN="30"
+CAN="20"
+
+dnc "emergenetic.dn"
+
+for FILE in ./scripts/*; do
+	FILE=${FILE##*/}
+	FILE=${FILE%.script}
+
+	dana "emergenetic" $FILE $GEN $CAN
+	
+	for DIR in ./cache/*; do
+		(cd "$DIR" && rm *.o)
+	done
+	cd results/ && rm *.txt && cd ..
+	tar -jcvf ./archives/$FILE.bz2 cache
+	rm -R cache
+	cp -a ./cachebackup ./cache
+done
+
+echo 'Complete.' >complete.txt
diff --git a/dat/scripts/difffile-html.script b/dat/scripts/difffile-html.script
new file mode 100644
index 0000000..5fdc7f7
--- /dev/null
+++ b/dat/scripts/difffile-html.script
@@ -0,0 +1,44 @@
+./htdocs/index.html
+./htdocs/index_big.html
+./htdocs/index_huge.html
+./htdocs/index_med.html
+./htdocs/index_small.html
+./htdocs/index_150KB.html
+./htdocs/index.html
+./htdocs/index_big.html
+./htdocs/index_huge.html
+./htdocs/index_med.html
+./htdocs/index_small.html
+./htdocs/index.html
+./htdocs/index_big.html
+./htdocs/index_huge.html
+./htdocs/index_med.html
+./htdocs/index_small.html
+./htdocs/index_150KB.html
+./htdocs/index.html
+./htdocs/index_big.html
+./htdocs/index_huge.html
+./htdocs/index_med.html
+./htdocs/index_small.html
+./htdocs/index.html
+./htdocs/index_big.html
+./htdocs/index_huge.html
+./htdocs/index_med.html
+./htdocs/index_small.html
+./htdocs/index_150KB.html
+./htdocs/index.html
+./htdocs/index_big.html
+./htdocs/index_huge.html
+./htdocs/index_med.html
+./htdocs/index_small.html
+./htdocs/index.html
+./htdocs/index_big.html
+./htdocs/index_huge.html
+./htdocs/index_med.html
+./htdocs/index_small.html
+./htdocs/index_150KB.html
+./htdocs/index.html
+./htdocs/index_big.html
+./htdocs/index_huge.html
+./htdocs/index_med.html
+./htdocs/index_small.html
\ No newline at end of file
diff --git a/dat/scripts/difffile-images.script b/dat/scripts/difffile-images.script
new file mode 100644
index 0000000..4e79cd2
--- /dev/null
+++ b/dat/scripts/difffile-images.script
@@ -0,0 +1,48 @@
+./htdocs/image_med.jpg
+./htdocs/image_small.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_small.jpg
+./htdocs/image_big.jpg
+./htdocs/image_small.jpg
+./htdocs/image_big.jpg
+./htdocs/image_small.jpg
+./htdocs/image_big.jpg
+./htdocs/image_big.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_small.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_small.jpg
+./htdocs/image_big.jpg
+./htdocs/image_small.jpg
+./htdocs/image_big.jpg
+./htdocs/image_small.jpg
+./htdocs/image_big.jpg
+./htdocs/image_big.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_small.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_small.jpg
+./htdocs/image_big.jpg
+./htdocs/image_small.jpg
+./htdocs/image_big.jpg
+./htdocs/image_small.jpg
+./htdocs/image_big.jpg
+./htdocs/image_big.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_small.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_small.jpg
+./htdocs/image_big.jpg
+./htdocs/image_small.jpg
+./htdocs/image_big.jpg
+./htdocs/image_small.jpg
+./htdocs/image_big.jpg
+./htdocs/image_big.jpg
+./htdocs/image_med.jpg
\ No newline at end of file
diff --git a/dat/scripts/difffile-large.script b/dat/scripts/difffile-large.script
new file mode 100644
index 0000000..a8e66fc
--- /dev/null
+++ b/dat/scripts/difffile-large.script
@@ -0,0 +1,40 @@
+./htdocs/image_big.jpg
+./htdocs/index_150KB.html
+./htdocs/index_big.html
+./htdocs/image_big.jpg
+./htdocs/index_huge.html
+./htdocs/index_big.html
+./htdocs/image_big.jpg
+./htdocs/image_big.jpg
+./htdocs/index_150KB.html
+./htdocs/index_big.html
+./htdocs/image_big.jpg
+./htdocs/index_huge.html
+./htdocs/index_big.html
+./htdocs/image_big.jpg
+./htdocs/image_big.jpg
+./htdocs/index_150KB.html
+./htdocs/index_big.html
+./htdocs/image_big.jpg
+./htdocs/index_big.html
+./htdocs/index_big.html
+./htdocs/image_big.jpg
+./htdocs/index_150KB.html
+./htdocs/index_big.html
+./htdocs/image_big.jpg
+./htdocs/index_huge.html
+./htdocs/index_big.html
+./htdocs/image_big.jpg
+./htdocs/image_big.jpg
+./htdocs/index_150KB.html
+./htdocs/index_big.html
+./htdocs/image_big.jpg
+./htdocs/index_huge.html
+./htdocs/index_big.html
+./htdocs/image_big.jpg
+./htdocs/image_big.jpg
+./htdocs/index_150KB.html
+./htdocs/index_big.html
+./htdocs/image_big.jpg
+./htdocs/index_big.html
+./htdocs/index_big.html
\ No newline at end of file
diff --git a/dat/scripts/difffile-small.script b/dat/scripts/difffile-small.script
new file mode 100644
index 0000000..f4449ce
--- /dev/null
+++ b/dat/scripts/difffile-small.script
@@ -0,0 +1,40 @@
+./htdocs/image_small.jpg
+./htdocs/index_small.html
+./htdocs/index_small.html
+./htdocs/image_small.jpg
+./htdocs/index_small.html
+./htdocs/index_small.html
+./htdocs/image_small.jpg
+./htdocs/image_small.jpg
+./htdocs/index_small.html
+./htdocs/index_small.html
+./htdocs/image_small.jpg
+./htdocs/index_small.html
+./htdocs/index_small.html
+./htdocs/image_small.jpg
+./htdocs/image_small.jpg
+./htdocs/index_small.html
+./htdocs/index_small.html
+./htdocs/image_small.jpg
+./htdocs/index_small.html
+./htdocs/index_small.html
+./htdocs/image_small.jpg
+./htdocs/index_small.html
+./htdocs/index_small.html
+./htdocs/image_small.jpg
+./htdocs/index_small.html
+./htdocs/index_small.html
+./htdocs/image_small.jpg
+./htdocs/image_small.jpg
+./htdocs/index_small.html
+./htdocs/index_small.html
+./htdocs/image_small.jpg
+./htdocs/index_small.html
+./htdocs/index_small.html
+./htdocs/image_small.jpg
+./htdocs/image_small.jpg
+./htdocs/index_small.html
+./htdocs/index_small.html
+./htdocs/image_small.jpg
+./htdocs/index_small.html
+./htdocs/index_small.html
\ No newline at end of file
diff --git a/dat/scripts/difffile.script b/dat/scripts/difffile.script
new file mode 100644
index 0000000..ea54679
--- /dev/null
+++ b/dat/scripts/difffile.script
@@ -0,0 +1,40 @@
+./htdocs/image_med.jpg
+./htdocs/index_150KB.html
+./htdocs/index_small.html
+./htdocs/image_big.jpg
+./htdocs/index.html
+./htdocs/index_med.html
+./htdocs/image_small.jpg
+./htdocs/image_med.jpg
+./htdocs/index_150KB.html
+./htdocs/index_small.html
+./htdocs/image_big.jpg
+./htdocs/index.html
+./htdocs/index_med.html
+./htdocs/image_small.jpg
+./htdocs/image_med.jpg
+./htdocs/index_150KB.html
+./htdocs/index_small.html
+./htdocs/image_big.jpg
+./htdocs/index.html
+./htdocs/index_med.html
+./htdocs/image_med.jpg
+./htdocs/index_150KB.html
+./htdocs/index_small.html
+./htdocs/image_big.jpg
+./htdocs/index.html
+./htdocs/index_med.html
+./htdocs/image_small.jpg
+./htdocs/image_med.jpg
+./htdocs/index_150KB.html
+./htdocs/index_small.html
+./htdocs/image_big.jpg
+./htdocs/index.html
+./htdocs/index_med.html
+./htdocs/image_small.jpg
+./htdocs/image_med.jpg
+./htdocs/index_150KB.html
+./htdocs/index_small.html
+./htdocs/image_big.jpg
+./htdocs/index.html
+./htdocs/index_med.html
\ No newline at end of file
diff --git a/dat/scripts/samefile-html.script b/dat/scripts/samefile-html.script
new file mode 100644
index 0000000..54c36df
--- /dev/null
+++ b/dat/scripts/samefile-html.script
@@ -0,0 +1,40 @@
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
+./htdocs/index_med.html
\ No newline at end of file
diff --git a/dat/scripts/samefile-images.script b/dat/scripts/samefile-images.script
new file mode 100644
index 0000000..4f6d56a
--- /dev/null
+++ b/dat/scripts/samefile-images.script
@@ -0,0 +1,40 @@
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
+./htdocs/image_med.jpg
\ No newline at end of file
diff --git a/index.html b/index.html
new file mode 100644
index 0000000..0e34078
--- /dev/null
+++ b/index.html
@@ -0,0 +1,68 @@
+<h1>SCC.300 Final Year Project</h1>
+
+<h3>Contact</h3>
+
+<p>Ben Goldsworthy (33576556) - <a href="mailto:me@bengoldsworthy.uk">Email</a></p>
+
+<h3>Introduction</h3>
+
+<p>This is the landing page for my final year project: &lsquo;EmerGen(e)tic: Exploring the use of genetic algorithms in distributed emergent systems&rsquo;.</p>
+
+<h3>Abstract</h3>
+
+<p>&ldquo;Adaptive and emergent systems exist to attempt to answer the deficiencies inherent to distributed systems, and the necessarily finite ability of any programmer to predict all possible eventualities in which his software may one day find itself. This paper argues that these systems fail to go far enough, and then proposes a further development&mdash;genetic systems&mdash;which utilises evolutionary programming to extend the versatility of a given system massively, if not infinitely. This paper proceeds to detail the EmerGen(e)tic framework for rapidly testing genetic algorithm modules within emergent systems, as well as an example module pertaining to the cache updating behaviour of a web server. This paper concludes by proposing further avenues of potentially-fruitful research based upon these programs and its findings.&rdquo;</p>
+
+<h3>Files</h3>
+
+<ul>
+   <li><a href="report/final-report.pdf">Report</a></li>
+   <li><b>Sources</b>
+      <ul>
+         <li><b>EmerGen(e)tic</b>
+            <ul>
+               <li><a href="src/emergenetic/README.md">Readme</a></li>
+               <li><a href="src/emergenetic/LICENSE.md">License</a></li>
+               <li><a href="src/emergenetic/emergenetic.dn">`emergenetic.dn`</a></li>
+               <li><b>HelloWorld module</b>
+                  <ul>
+                     <li><a href="src/helloworld/README.md">Readme</a></li>
+                     <li><a href="src/helloworld/LICENSE.md">License</a></li>
+                     <li><a href="src/helloworld/project/helloworld/mutator.py">`mutator.py`</a></li>
+                     <li><a href="src/helloworld/project/helloworld/setup.sh">`setup.sh`</a></li>
+                     <li><b>HelloWorld Run Results</b>
+                        <ul>
+                           <li><a href="dat/helloworld/output0.txt">With probailities set to 0 %</a></li>
+                           <li><a href="dat/helloworld/output50.txt">With probailities set to 50 %</a></li>
+                           <li><a href="dat/helloworld/output100.txt">With probailities set to 100 %</a></li>
+                        </ul>
+                     </li>
+                  </ul>
+               </li>
+               <li><b>CachingPolicy module</b>
+                  <ul>
+                     <li><a href="src/cachingpolicy/README.md">Readme</a></li>
+                     <li><a href="src/cachingpolicy/LICENSE.md">License</a></li>
+                     <li><a href="src/cachingpolicy/emergenetic.dn">`emergenetic.dn`</a> (with implemented `runCandidates()` method)</li>
+                     <li><a href="src/cachingpolicy/project/cachingpolicy/mutator.py">`mutator.py`</a></li>
+                     <li><a href="src/cachingpolicy/project/cachingpolicy/config.conf">`config.conf`</a></li>
+                     <li><a href="src/cachingpolicy/project/cachingpolicy/setup.sh">`setup.sh`</a></li>
+                     <li><a href="src/cachingpolicy/cachebackup/CacheHandlerBase.dn">`CacheHandler*` base</a></li>
+                     <li><a href="dat/runTests.sh">Example test runs Bashscript</a></li>
+                     <li><b>CachingPolicy Run Results</b>
+                        <ul>
+                           <li><a href="dat/output (normal).txt">Example `output.txt`</a></li>
+                           <li><a href="dat/output (verbose).txt">Example `output.txt` (with 'verbose' flag enabled)</a></li>
+                           <li><a href="dat/archives/difffile.bz2">Example archived test run (`difffile`)</a></li>
+                           <li><a href="dat/cache/difffile-large/12/CacheHandler12_8.dn">Example `CacheHandler` chromosome (`difffile-large`, `CacheHandler12_8.dn`)</a></li>
+                           <li><a href="dat/scripts/difffile-images.script">Example `.script` file</a></li>
+                           <li>Results featured in report: `<a href="dat/results/results_difffile-large.ods">difffile-large</a>` and `<a href="dat/results/results_samefile-images.ods">samefile-images</a>`</li>
+                           <li><a href="dat/cache/difffile-large/17/chromosomes.txt">Gen. 18 chromsomes</a></li>
+                        </ul>
+                     </li>
+                  </ul>
+               </li>
+            </ul>
+         </li>
+      </ul>
+   </li>
+</ul>
\ No newline at end of file
diff --git a/report/final-report.aux b/report/final-report.aux
new file mode 100644
index 0000000..8617c76
--- /dev/null
+++ b/report/final-report.aux
@@ -0,0 +1,164 @@
+\relax 
+\citation{distsys}
+\citation{reliable}
+\citation{machinecentric}
+\citation{antenna}
+\citation{genprog}
+\citation{ants}
+\@writefile{toc}{\contentsline {section}{\numberline {1}Introduction}{4}}
+\newlabel{sec:introduction}{{1}{4}}
+\@writefile{loa}{\contentsline {algorithm}{\numberline {1}{\ignorespaces Basic genetic algorithm}}{5}}
+\newlabel{alg1}{{1}{5}}
+\citation{bugcost}
+\citation{1000}
+\citation{cni}
+\citation{unix}
+\citation{geometry}
+\citation{email}
+\citation{rfc}
+\citation{distsys}
+\@writefile{toc}{\contentsline {section}{\numberline {2}Background}{7}}
+\newlabel{sec:background}{{2}{7}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.1}Assumptions}{7}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.2}Distributed and Adaptive Systems}{7}}
+\citation{dana}
+\citation{dana}
+\citation{machinecentric}
+\citation{machinecentric}
+\citation{losingcontrol}
+\citation{rex}
+\citation{fusion}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.3}Emergent Systems}{8}}
+\citation{floyd}
+\citation{genprog}
+\citation{security}
+\citation{antenna}
+\citation{ants}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.4}`Genetic Systems'}{9}}
+\@writefile{toc}{\contentsline {section}{\numberline {3}Design}{10}}
+\newlabel{sec:design}{{3}{10}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.1}EmerGen(e)tic}{10}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.2}The Web Server}{10}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {3.2.1}How a web server works}{10}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {3.2.2}Added extras}{11}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {3.2.3}A tale of two web servers}{11}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.3}Caching}{12}}
+\newlabel{sec:caching}{{3.3}{12}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.4}The `Cache Policy' Genetic Algorithm}{12}}
+\@writefile{toc}{\contentsline {section}{\numberline {4}Implementation: EmerGen(e)tic}{14}}
+\newlabel{sec:implementation}{{4}{14}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.1}Folder Structure}{14}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.2}\lstinline |emergenetic.dn|}{14}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {4.2.1}\lstinline |App:main()|}{14}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {4.2.2}\lstinline |runGeneration()|}{14}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {4.2.3}\lstinline |runCandidate()|}{14}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {4.2.4}\lstinline |printResults()|}{14}}
+\@writefile{toc}{\contentsline {section}{\numberline {5}Implementation: \lstinline |cachingpolicy|}{15}}
+\newlabel{sec:cachingpolicyimpl}{{5}{15}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.1}Folder Structure}{15}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.2}Genetic Algorithm search space}{15}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.3}\lstinline |CacheHandlerBase.dn|}{16}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.3.1}\lstinline |CacheHandler:getGetCachedResponse()|}{16}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.3.2}\lstinline |CacheHandler:updateCache()|}{16}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.3.3}\lstinline |CacheHandler:clearCache()|}{16}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.3.4}\lstinline |nthMostFrequentlyUsed()|, \lstinline |nthMostRecentlyUsed()| \& \lstinline |random()|}{16}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.3.5}\lstinline |resolve()|}{16}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.4}\lstinline |emergenetic.dn|}{16}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.5}\lstinline |cachingpolicy/mutator.py|}{16}}
+\newlabel{sec:python}{{5.5}{16}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.5.1}\lstinline |getSubLists()|}{17}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.5.2}\lstinline |crossover()|}{17}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.5.3}\lstinline |mutate()|}{17}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.5.4}\lstinline |parse()| \& \lstinline |compile()|}{17}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.5.5}\lstinline |createInitialPop()|}{17}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.5.6}\lstinline |readChromosomeFromFile()| \& \lstinline |writeChromosomeToFile()|}{17}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.5.7}\lstinline |hasSubTrees()|}{17}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {5.5.8}\lstinline |main()|}{17}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.6}\lstinline |cachingpolicy/config.conf|}{17}}
+\@writefile{toc}{\contentsline {section}{\numberline {6}The System in Operation}{18}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {6.1}Creating a Module}{18}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {6.1.1}Files}{18}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {6.1.2}Implementation}{18}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {6.2}Creating Scripts}{18}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {6.3}Running EmerGen(e)tic}{18}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {6.4}Background Tests}{20}}
+\@writefile{toc}{\contentsline {section}{\numberline {7}Testing \& Evaluation}{21}}
+\newlabel{sec:testing}{{7}{21}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {7.1}Testing EmerGen(e)tic}{21}}
+\@writefile{lol}{\contentsline {lstlisting}{../dat/helloworld/output50.txt}{21}}
+\@writefile{lol}{\contentsline {lstlisting}{../dat/helloworld/output50.txt}{21}}
+\@writefile{lol}{\contentsline {lstlisting}{../dat/helloworld/output0.txt}{21}}
+\@writefile{lol}{\contentsline {lstlisting}{../dat/helloworld/output0.txt}{22}}
+\@writefile{lol}{\contentsline {lstlisting}{../dat/helloworld/output100.txt}{22}}
+\@writefile{lol}{\contentsline {lstlisting}{../dat/helloworld/output100.txt}{22}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {7.2}Testing \lstinline |cachingpolicy|}{23}}
+\newlabel{sec:testingcache}{{7.2}{23}}
+\@writefile{lof}{\contentsline {figure}{\numberline {1}{\ignorespaces }}{23}}
+\newlabel{fig:difffile-large}{{1}{23}}
+\@writefile{lof}{\contentsline {figure}{\numberline {2}{\ignorespaces }}{23}}
+\newlabel{fig:difffile-large-wo}{{2}{23}}
+\@writefile{lof}{\contentsline {figure}{\numberline {3}{\ignorespaces }}{23}}
+\newlabel{fig:samefile-images}{{3}{23}}
+\@writefile{lof}{\contentsline {figure}{\numberline {4}{\ignorespaces }}{23}}
+\newlabel{fig:samefile-images-wo}{{4}{23}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {7.3}Evaluation}{24}}
+\newlabel{sec:eval}{{7.3}{24}}
+\@writefile{toc}{\contentsline {section}{\numberline {8}Conclusion}{25}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {8.1}Future Development}{25}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {8.1.1}Completing the original goal of finding the optimal conditions for the genetic algorithm}{25}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {8.1.2}Designing more modules}{25}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {8.1.3}A more `Danatically'-designed EmerGen(e)tic}{25}}
+\citation{meta}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {8.1.4}Issues within the present \lstinline |cachingpolicy| module}{26}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {8.1.5}Putting human developers further out of work (through meta-learning)}{26}}
+\bibstyle{IEEEtran}
+\bibdata{final-report}
+\bibcite{distsys}{1}
+\bibcite{reliable}{2}
+\bibcite{machinecentric}{3}
+\bibcite{antenna}{4}
+\bibcite{genprog}{5}
+\bibcite{ants}{6}
+\bibcite{bugcost}{7}
+\bibcite{1000}{8}
+\bibcite{cni}{9}
+\bibcite{unix}{10}
+\bibcite{geometry}{11}
+\bibcite{email}{12}
+\bibcite{rfc}{13}
+\bibcite{dana}{14}
+\bibcite{losingcontrol}{15}
+\bibcite{rex}{16}
+\bibcite{fusion}{17}
+\bibcite{floyd}{18}
+\bibcite{security}{19}
+\bibcite{meta}{20}
+\@writefile{toc}{\contentsline {section}{References}{27}}
+\@writefile{toc}{\contentsline {section}{Appendix\nobreakspace  A: \lstinline |emergenetic.dn|}{28}}
+\newlabel{appendix:emergen}{{A}{28}}
+\@writefile{lol}{\contentsline {lstlisting}{../src/emergenetic/emergenetic.dn}{28}}
+\@writefile{toc}{\contentsline {section}{Appendix\nobreakspace  B: \lstinline |helloworld/mutator.py|}{32}}
+\newlabel{appendix:helloworld}{{B}{32}}
+\@writefile{lol}{\contentsline {lstlisting}{../src/helloworld/project/helloworld/mutator.py}{32}}
+\@writefile{toc}{\contentsline {section}{Appendix\nobreakspace  C: \lstinline |cachingpolicy|}{34}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {C.1}\lstinline |CacheHandlerBase.dn|}{34}}
+\newlabel{appendix:base}{{C.1}{34}}
+\@writefile{lol}{\contentsline {lstlisting}{../src/cachingpolicy/cachebackup/CacheHandlerBase.dn}{34}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {C.2}\lstinline |mutator.py|}{39}}
+\newlabel{appendix:genetic}{{C.2}{39}}
+\@writefile{lol}{\contentsline {lstlisting}{../src/cachingpolicy/project/cachingpolicy/mutator.py}{39}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {C.3}\lstinline |emergenetic.dn|'s \lstinline |runCandidates()| method}{44}}
+\newlabel{appendix:runcand}{{C.3}{44}}
+\@writefile{lol}{\contentsline {lstlisting}{../src/cachingpolicy/emergenetic.dn}{44}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {C.4}\lstinline |setup.sh|}{45}}
+\newlabel{appendix:setup}{{C.4}{45}}
+\@writefile{lol}{\contentsline {lstlisting}{../src/cachingpolicy/project/cachingpolicy/setup.sh}{45}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {C.5}\lstinline |config.conf|}{45}}
+\newlabel{appendix:settings}{{C.5}{45}}
+\@writefile{lol}{\contentsline {lstlisting}{../src/cachingpolicy/project/cachingpolicy/config.conf}{46}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {C.6}Gen. 18 chromosomes}{46}}
+\newlabel{appendix:chromosomes}{{C.6}{46}}
+\@writefile{lol}{\contentsline {lstlisting}{../dat/cache/difffile\textendash large/17/chromosomes.txt}{46}}
+\@writefile{toc}{\contentsline {section}{Appendix\nobreakspace  D: \lstinline |runTests.sh|}{47}}
+\newlabel{appendix:bash}{{D}{47}}
+\@writefile{lol}{\contentsline {lstlisting}{../dat/runTests.sh}{47}}
diff --git a/report/final-report.bbl b/report/final-report.bbl
new file mode 100644
index 0000000..2287e56
--- /dev/null
+++ b/report/final-report.bbl
@@ -0,0 +1,130 @@
+% Generated by IEEEtran.bst, version: 1.14 (2015/08/26)
+\begin{thebibliography}{10}
+\providecommand{\url}[1]{#1}
+\csname url@samestyle\endcsname
+\providecommand{\newblock}{\relax}
+\providecommand{\bibinfo}[2]{#2}
+\providecommand{\BIBentrySTDinterwordspacing}{\spaceskip=0pt\relax}
+\providecommand{\BIBentryALTinterwordstretchfactor}{4}
+\providecommand{\BIBentryALTinterwordspacing}{\spaceskip=\fontdimen2\font plus
+\BIBentryALTinterwordstretchfactor\fontdimen3\font minus
+  \fontdimen4\font\relax}
+\providecommand{\BIBforeignlanguage}[2]{{%
+\expandafter\ifx\csname l@#1\endcsname\relax
+\typeout{** WARNING: IEEEtran.bst: No hyphenation pattern has been}%
+\typeout{** loaded for the language `#1'. Using the pattern for}%
+\typeout{** the default language instead.}%
+\else
+\language=\csname l@#1\endcsname
+\fi
+#2}}
+\providecommand{\BIBdecl}{\relax}
+\BIBdecl
+
+\bibitem{distsys}
+G.~F. Coulouris, J.~Dollimore, T.~Kindberg, and G.~Blair, \emph{Distributed
+  Systems: Concepts and Design}, 5th~ed.\hskip 1em plus 0.5em minus 0.4em\relax
+  Addison-Wesley, 2012.
+
+\bibitem{reliable}
+\BIBentryALTinterwordspacing
+E.~Redwine and J.~L. Holliday, ``Reliability of distributed systems.''
+  [Online]. Available: \url{http://www.cse.scu.edu/~jholliday/REL-EAR.htm}
+\BIBentrySTDinterwordspacing
+
+\bibitem{machinecentric}
+R.~Rodrigues~Filho and B.~F. Porter, ``Experiments with a machine-centric
+  approach to realise distributed emergent software systems,'' 2016.
+
+\bibitem{antenna}
+G.~Hornby, A.~Globus, D.~Linden, and J.~Lohn, ``Automated antenna design with
+  evolutionary algorithms,'' in \emph{Space 2006}, 2015, p. 7242.
+
+\bibitem{genprog}
+C.~Le~Goues, M.~Dewey-Vogt, S.~Forrest, and W.~Weimer, ``A systematic study of
+  automated program repair: Fixing 55 out of 105 bugs for \$8 each,'' in
+  \emph{Software Engineering (ICSE), 2012 34th International Conference
+  on}.\hskip 1em plus 0.5em minus 0.4em\relax IEEE, 2012, pp. 3--13.
+
+\bibitem{ants}
+B.~Goldsworthy, ```thanks, ants. thants.': Applying genetic algorithms to
+  simulated ants to produce higher-fitness generations,'' unpublished.
+
+\bibitem{bugcost}
+M.~Dawson, D.~N. Burrell, E.~Rahim, and S.~Brewster, ``Integrating software
+  assurance into the software development life cycle (sdlc),'' \emph{Journal of
+  Information Systems Technology and Planning}, vol.~3, no.~6, 2010.
+
+\bibitem{1000}
+S.~McConnell, \emph{Code complete}.\hskip 1em plus 0.5em minus 0.4em\relax
+  Pearson Education, 2004.
+
+\bibitem{cni}
+B.~Goldsworthy, ``Critical infrastructures protection: the responsibility of
+  government or of companies?'' unpublished.
+
+\bibitem{unix}
+E.~S. Raymond, \emph{The art of Unix programming}.\hskip 1em plus 0.5em minus
+  0.4em\relax Addison-Wesley Professional, 2003.
+
+\bibitem{geometry}
+D.~Muder, \emph{The Unreasonable Influence of Geometry}, 2000.
+
+\bibitem{email}
+\BIBentryALTinterwordspacing
+L.~Lamport, ``Distribution,'' May 1987. [Online]. Available:
+  \url{https://www.microsoft.com/en-us/research/publication/distribution/}
+\BIBentrySTDinterwordspacing
+
+\bibitem{rfc}
+\BIBentryALTinterwordspacing
+S.~Crocker, ``New host-host protocol,'' Internet Requests for Comments, RFC
+  Editor, RFC~33, February 1970, \url{http://www.rfc-editor.org/rfc/rfc33.txt}.
+  [Online]. Available: \url{http://www.rfc-editor.org/rfc/rfc33.txt}
+\BIBentrySTDinterwordspacing
+
+\bibitem{dana}
+B.~F. Porter, ``Runtime modularity in complex structures: A component model for
+  fine grained runtime adaptation,'' in \emph{Proceedings of the 17th
+  international ACM Sigsoft symposium on Component-based software
+  engineering}.\hskip 1em plus 0.5em minus 0.4em\relax ACM, 2014, pp. 29--34.
+
+\bibitem{losingcontrol}
+B.~F. Porter and R.~Rodrigues~Filho, ``Losing control: The case for emergent
+  software systems using autonomous assembly, perception, and learning,'' in
+  \emph{Self-Adaptive and Self-Organizing Systems (SASO), 2016 IEEE 10th
+  International Conference on}.\hskip 1em plus 0.5em minus 0.4em\relax IEEE,
+  2016, pp. 40--49.
+
+\bibitem{rex}
+B.~Porter, M.~Grieves, R.~Rodrigues~Filho, and D.~Leslie, ``Re$^{\text{x}}$: A
+  development platform and online learning approach for runtime emergent
+  software systems,'' in \emph{Proceedings of the 12th USENIX Symposium on
+  Operating Systems Design and Implementation. USENIX}, 2016.
+
+\bibitem{fusion}
+\BIBentryALTinterwordspacing
+A.~Elkhodary, N.~Esfahani, and S.~Malek, ``Fusion: A framework for engineering
+  self-tuning self-adaptive software systems,'' in \emph{Proceedings of the
+  Eighteenth ACM SIGSOFT International Symposium on Foundations of Software
+  Engineering}, ser. FSE '10.\hskip 1em plus 0.5em minus 0.4em\relax New York,
+  NY, USA: ACM, 2010, pp. 7--16. [Online]. Available:
+  \url{http://doi.acm.org/10.1145/1882291.1882296}
+\BIBentrySTDinterwordspacing
+
+\bibitem{floyd}
+R.~W. Floyd, ``The paradigms of programming,'' \emph{Communications of the
+  ACM}, vol.~22, no.~8, pp. 455--460, 1979.
+
+\bibitem{security}
+J.~V. Hansen, P.~B. Lowry, R.~D. Meservy, and D.~M. McDonald, ``Genetic
+  programming for prevention of cyberterrorism through dynamic and evolving
+  intrusion detection,'' \emph{Decision Support Systems}, vol.~43, no.~4, pp.
+  1362--1374, 2007.
+
+\bibitem{meta}
+J.~Schmidhuber, ``Evolutionary principles in self-referential learning,''
+  \emph{On learning how to learn: The meta-meta-... hook.) Diploma thesis,
+  Institut f. Informatik, Tech. Univ. Munich}, 1987.
+
+\end{thebibliography}
diff --git a/report/final-report.bib b/report/final-report.bib
new file mode 100644
index 0000000..a43baf5
--- /dev/null
+++ b/report/final-report.bib
@@ -0,0 +1,193 @@
+@IEEEtranBSTCTL{IEEEexample:BSTcontrol,
+CTLdash_repeated_names = "no",
+}
+
+@incollection{antenna,
+  title={Automated antenna design with evolutionary algorithms},
+  author={Hornby, Gregory and Globus, Al and Linden, Derek and Lohn, Jason},
+  booktitle={Space 2006},
+  pages={7242},
+  year={2015}
+}
+
+@inproceedings{genprog,
+  title={A systematic study of automated program repair: Fixing 55 out of 105 bugs for \$8 each},
+  author={Le Goues, Claire and Dewey-Vogt, Michael and Forrest, Stephanie and Weimer, Westley},
+  booktitle={Software Engineering (ICSE), 2012 34th International Conference on},
+  pages={3--13},
+  year={2012},
+  organization={IEEE}
+}
+
+@article{ants,
+  title={`Thanks, ants. Thants.': Applying genetic algorithms to simulated ants to produce higher-fitness generations},
+  author={Ben Goldsworthy},
+  year={unpublished}
+}
+
+@inproceedings{dana,
+  title={Runtime modularity in complex structures: A component model for fine grained runtime adaptation},
+  author={Porter, Barry Francis},
+  booktitle={Proceedings of the 17th international ACM Sigsoft symposium on Component-based software engineering},
+  pages={29--34},
+  year={2014},
+  organization={ACM}
+}
+
+@article{machinecentric,
+  title={Experiments with a machine-centric approach to realise distributed emergent software systems},
+  author={Rodrigues Filho, Roberto and Porter, Barry Francis},
+  year={2016},
+  publisher={ACM}
+}
+
+@article{meta,
+  title={Evolutionary principles in self-referential learning},
+  author={Schmidhuber, Jurgen},
+  journal={On learning how to learn: The meta-meta-... hook.) Diploma thesis, Institut f. Informatik, Tech. Univ. Munich},
+  year={1987}
+}
+
+@book{distsys,
+	author={Coulouris, George F and Dollimore, Jean and Kindberg, Tim and Blair, Gordon},
+	title={Distributed Systems: Concepts and Design},
+	place={Boston, Mass.},
+	edition={5},
+	publisher={Addison-Wesley},
+	year={2012}
+}
+
+@misc{reliable,
+	author={Redwine, Erick and Holliday, JoAnne L},
+	title={Reliability of Distributed Systems},
+	url={http://www.cse.scu.edu/~jholliday/REL-EAR.htm},
+	urldate={2017-3-2},
+	journal={Cse.scu.edu}
+}
+
+@inproceedings{losingcontrol,
+  title={Losing Control: The Case for Emergent Software Systems Using Autonomous Assembly, Perception, and Learning},
+  author={Porter, Barry Francis and Rodrigues Filho, Roberto},
+  booktitle={Self-Adaptive and Self-Organizing Systems (SASO), 2016 IEEE 10th International Conference on},
+  pages={40--49},
+  year={2016},
+  organization={IEEE}
+}
+
+@inproceedings{rex,
+  title={RE$^{\text{X}}$: A development platform and online learning approach for runtime emergent software systems},
+  author={Porter, Barry and Grieves, Matthew and Rodrigues Filho, Roberto and Leslie, David},
+  booktitle={Proceedings of the 12th USENIX Symposium on Operating Systems Design and Implementation. USENIX},
+  year={2016}
+}
+
+@inproceedings{fusion,
+ author = {Elkhodary, Ahmed and Esfahani, Naeem and Malek, Sam},
+ title = {FUSION: A Framework for Engineering Self-tuning Self-adaptive Software Systems},
+ booktitle = {Proceedings of the Eighteenth ACM SIGSOFT International Symposium on Foundations of Software Engineering},
+ series = {FSE '10},
+ year = {2010},
+ isbn = {978-1-60558-791-2},
+ location = {Santa Fe, New Mexico, USA},
+ pages = {7--16},
+ numpages = {10},
+ url = {http://doi.acm.org/10.1145/1882291.1882296},
+ doi = {10.1145/1882291.1882296},
+ acmid = {1882296},
+ publisher = {ACM},
+ address = {New York, NY, USA},
+ keywords = {feature-orientation, learning, qos analysis, self-adaptation},
+} 
+
+@article{bugcost,
+  title={Integrating Software Assurance into the Software Development Life Cycle (SDLC)},
+  author={Dawson, Maurice and Burrell, Darrell N and Rahim, Emad and Brewster, Stephen},
+  journal={Journal of Information Systems Technology and Planning},
+  volume={3},
+  number={6},
+  year={2010}
+}
+
+@book{1000,
+  title={Code complete},
+  author={McConnell, Steve},
+  year={2004},
+  publisher={Pearson Education}
+}
+
+@book{geometry,
+  title={The Unreasonable Influence of Geometry},
+  author={Muder, Doug},
+  year={2000}
+}
+
+@techreport{RFC,
+  author = {S.D. Crocker},
+  title = {New Host-Host Protocol},
+  howpublished = {Internet Requests for Comments},
+  type = {RFC},
+  number = {33},
+  year = {1970},
+  month = {February},
+  issn = {2070-1721},
+  publisher = {RFC Editor},
+  institution = {RFC Editor},
+  url = {http://www.rfc-editor.org/rfc/rfc33.txt},
+  note = {\url{http://www.rfc-editor.org/rfc/rfc33.txt}},
+}
+
+@other{email,
+author = {Lamport, Leslie},
+title = {Distribution},
+booktitle = {},
+year = {1987},
+month = {May},
+abstract = {This message is the source of the following observation, which has been quoted (and misquoted) rather widely: 
+
+A distributed system is one in which the failure of a computer you didn't even know existed can render your own computer unusable. 
+},
+publisher = {},
+url = {https://www.microsoft.com/en-us/research/publication/distribution/},
+address = {},
+pages = {},
+journal = {},
+volume = {},
+chapter = {},
+isbn = {},
+}
+
+@article{floyd,
+  title={The paradigms of programming},
+  author={Floyd, Robert W},
+  journal={Communications of the ACM},
+  volume={22},
+  number={8},
+  pages={455--460},
+  year={1979},
+  publisher={ACM}
+}
+
+@article{cni,
+  title={Critical infrastructures protection: the responsibility of Government or of companies?},
+  author={Goldsworthy, Ben},
+  year={unpublished}
+}
+
+@book{unix,
+  title={The art of Unix programming},
+  author={Raymond, Eric S},
+  year={2003},
+  publisher={Addison-Wesley Professional}
+}
+
+@article{security,
+  title={Genetic programming for prevention of cyberterrorism through dynamic and evolving intrusion detection},
+  author={Hansen, James V and Lowry, Paul Benjamin and Meservy, Rayman D and McDonald, Daniel M},
+  journal={Decision Support Systems},
+  volume={43},
+  number={4},
+  pages={1362--1374},
+  year={2007},
+  publisher={Elsevier}
+}
+
diff --git a/report/final-report.blg b/report/final-report.blg
new file mode 100644
index 0000000..fc2a560
--- /dev/null
+++ b/report/final-report.blg
@@ -0,0 +1,15 @@
+This is BibTeX, Version 0.99dThe top-level auxiliary file: final-report.aux
+The style file: IEEEtran.bst
+Database file #1: final-report.bib
+Warning--entry type for "email" isn't style-file defined
+--line 139 of file final-report.bib
+-- IEEEtran.bst version 1.14 (2015/08/26) by Michael Shell.
+-- http://www.michaelshell.org/tex/ieeetran/bibtex/
+-- See the "IEEEtran_bst_HOWTO.pdf" manual for usage information.
+Warning--empty journal in machinecentric
+Warning--empty journal in ants
+Warning--empty journal in cni
+Warning--missing publisher in geometry
+
+Done.
+(There were 5 warnings)
diff --git a/report/final-report.log b/report/final-report.log
new file mode 100644
index 0000000..a8c5c69
--- /dev/null
+++ b/report/final-report.log
@@ -0,0 +1,1203 @@
+This is pdfTeX, Version 3.1415926-2.5-1.40.14 (MiKTeX 2.9) (preloaded format=pdflatex 2014.8.24)  22 MAR 2017 11:21
+entering extended mode
+**Z:/scc300/report/final-report.tex
+(Z:/scc300/report/final-report.tex
+LaTeX2e <2011/06/27>
+Babel <v3.8m> and hyphenation patterns for english, afrikaans, ancientgreek, ar
+abic, armenian, assamese, basque, bengali, bokmal, bulgarian, catalan, coptic, 
+croatian, czech, danish, dutch, esperanto, estonian, farsi, finnish, french, ga
+lician, german, german-x-2013-05-26, greek, gujarati, hindi, hungarian, iceland
+ic, indonesian, interlingua, irish, italian, kannada, kurmanji, latin, latvian,
+ lithuanian, malayalam, marathi, mongolian, mongolianlmc, monogreek, ngerman, n
+german-x-2013-05-26, nynorsk, oriya, panjabi, pinyin, polish, portuguese, roman
+ian, russian, sanskrit, serbian, slovak, slovenian, spanish, swedish, swissgerm
+an, tamil, telugu, turkish, turkmen, ukenglish, ukrainian, uppersorbian, usengl
+ishmax, welsh, loaded.
+("C:\Program Files (x86)\MiKTeX\tex\latex\ieeetran\IEEEtran.cls"
+Document Class: IEEEtran 2015/08/26 V1.8b by Michael Shell
+-- See the "IEEEtran_HOWTO" manual for usage information.
+-- http://www.michaelshell.org/tex/ieeetran/
+\@IEEEtrantmpdimenA=\dimen102
+\@IEEEtrantmpdimenB=\dimen103
+\@IEEEtrantmpdimenC=\dimen104
+\@IEEEtrantmpcountA=\count79
+\@IEEEtrantmpcountB=\count80
+\@IEEEtrantmpcountC=\count81
+\@IEEEtrantmptoksA=\toks14
+LaTeX Font Info:    Try loading font information for OT1+ppl on input line 503.
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\psnfss\ot1ppl.fd"
+File: ot1ppl.fd 2001/06/04 font definitions for OT1/ppl.
+)
+-- Using IEEE Computer Society mode.
+-- Using 210mm x 297mm (a4) paper.
+-- Using PDF output.
+\@IEEEnormalsizeunitybaselineskip=\dimen105
+-- This is a 12 point document.
+\CLASSINFOnormalsizebaselineskip=\dimen106
+\CLASSINFOnormalsizeunitybaselineskip=\dimen107
+\IEEEnormaljot=\dimen108
+LaTeX Font Info:    Font shape `OT1/ppl/bx/n' in size <6.02249> not available
+(Font)              Font shape `OT1/ppl/b/n' tried instead on input line 1090.
+LaTeX Font Info:    Font shape `OT1/ppl/bx/it' in size <6.02249> not available
+(Font)              Font shape `OT1/ppl/b/it' tried instead on input line 1090.
+
+LaTeX Font Info:    Font shape `OT1/ppl/bx/n' in size <8.03> not available
+(Font)              Font shape `OT1/ppl/b/n' tried instead on input line 1090.
+LaTeX Font Info:    Font shape `OT1/ppl/bx/it' in size <8.03> not available
+(Font)              Font shape `OT1/ppl/b/it' tried instead on input line 1090.
+
+LaTeX Font Info:    Font shape `OT1/ppl/bx/n' in size <9.03374> not available
+(Font)              Font shape `OT1/ppl/b/n' tried instead on input line 1090.
+LaTeX Font Info:    Font shape `OT1/ppl/bx/it' in size <9.03374> not available
+(Font)              Font shape `OT1/ppl/b/it' tried instead on input line 1090.
+
+LaTeX Font Info:    Font shape `OT1/ppl/bx/n' in size <10.03749> not available
+(Font)              Font shape `OT1/ppl/b/n' tried instead on input line 1090.
+LaTeX Font Info:    Font shape `OT1/ppl/bx/it' in size <10.03749> not available
+
+(Font)              Font shape `OT1/ppl/b/it' tried instead on input line 1090.
+
+LaTeX Font Info:    Font shape `OT1/ppl/bx/n' in size <12.045> not available
+(Font)              Font shape `OT1/ppl/b/n' tried instead on input line 1090.
+LaTeX Font Info:    Font shape `OT1/ppl/bx/it' in size <12.045> not available
+(Font)              Font shape `OT1/ppl/b/it' tried instead on input line 1090.
+
+LaTeX Font Info:    Font shape `OT1/ppl/bx/n' in size <14.05249> not available
+(Font)              Font shape `OT1/ppl/b/n' tried instead on input line 1090.
+LaTeX Font Info:    Font shape `OT1/ppl/bx/it' in size <14.05249> not available
+
+(Font)              Font shape `OT1/ppl/b/it' tried instead on input line 1090.
+
+LaTeX Font Info:    Font shape `OT1/ppl/bx/n' in size <20.075> not available
+(Font)              Font shape `OT1/ppl/b/n' tried instead on input line 1090.
+LaTeX Font Info:    Font shape `OT1/ppl/bx/it' in size <20.075> not available
+(Font)              Font shape `OT1/ppl/b/it' tried instead on input line 1090.
+
+LaTeX Font Info:    Font shape `OT1/ppl/bx/n' in size <22.08249> not available
+(Font)              Font shape `OT1/ppl/b/n' tried instead on input line 1090.
+LaTeX Font Info:    Font shape `OT1/ppl/bx/it' in size <22.08249> not available
+
+(Font)              Font shape `OT1/ppl/b/it' tried instead on input line 1090.
+
+LaTeX Font Info:    Font shape `OT1/ppl/bx/n' in size <24.09> not available
+(Font)              Font shape `OT1/ppl/b/n' tried instead on input line 1090.
+LaTeX Font Info:    Font shape `OT1/ppl/bx/it' in size <24.09> not available
+(Font)              Font shape `OT1/ppl/b/it' tried instead on input line 1090.
+
+\IEEEquantizedlength=\dimen109
+\IEEEquantizedlengthdiff=\dimen110
+\IEEEquantizedtextheightdiff=\dimen111
+\IEEEilabelindentA=\dimen112
+\IEEEilabelindentB=\dimen113
+\IEEEilabelindent=\dimen114
+\IEEEelabelindent=\dimen115
+\IEEEdlabelindent=\dimen116
+\IEEElabelindent=\dimen117
+\IEEEiednormlabelsep=\dimen118
+\IEEEiedmathlabelsep=\dimen119
+\IEEEiedtopsep=\skip41
+\c@section=\count82
+\c@subsection=\count83
+\c@subsubsection=\count84
+\c@paragraph=\count85
+\c@IEEEsubequation=\count86
+\abovecaptionskip=\skip42
+\belowcaptionskip=\skip43
+\c@figure=\count87
+\c@table=\count88
+\@IEEEeqnnumcols=\count89
+\@IEEEeqncolcnt=\count90
+\@IEEEsubeqnnumrollback=\count91
+\@IEEEquantizeheightA=\dimen120
+\@IEEEquantizeheightB=\dimen121
+\@IEEEquantizeheightC=\dimen122
+\@IEEEquantizeprevdepth=\dimen123
+\@IEEEquantizemultiple=\count92
+\@IEEEquantizeboxA=\box26
+\@IEEEtmpitemindent=\dimen124
+\IEEEPARstartletwidth=\dimen125
+\c@IEEEbiography=\count93
+\@IEEEtranrubishbin=\box27
+) ("C:\Program Files (x86)\MiKTeX\tex\latex\blindtext\blindtext.sty"
+Package: blindtext 2012/01/06 V2.0 blindtext-Package
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\tools\xspace.sty"
+Package: xspace 2009/10/20 v1.13 Space after command names (DPC,MH)
+)
+\c@blindtext=\count94
+\c@Blindtext=\count95
+\c@blind@countparstart=\count96
+\blind@countxx=\count97
+\blindtext@numBlindtext=\count98
+\blind@countyy=\count99
+\c@blindlist=\count100
+\c@blindlistlevel=\count101
+\c@blindlist@level=\count102
+\blind@listitem=\count103
+\c@blind@listcount=\count104
+\c@blind@levelcount=\count105
+\blind@mathformula=\count106
+\blind@Mathformula=\count107
+\c@blind@randomcount=\count108
+\c@blind@randommax=\count109
+\c@blind@pangramcount=\count110
+\c@blind@pangrammax=\count111
+)
+("C:\Program Files (x86)\MiKTeX\tex\latex\graphics\color.sty"
+Package: color 2005/11/14 v1.0j Standard LaTeX Color (DPC)
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\00miktex\color.cfg"
+File: color.cfg 2007/01/18 v1.5 color configuration of teTeX/TeXLive
+)
+Package color Info: Driver file: pdftex.def on input line 130.
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\pdftex-def\pdftex.def"
+File: pdftex.def 2011/05/27 v0.06d Graphics/color for pdfTeX
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\oberdiek\infwarerr.sty"
+Package: infwarerr 2010/04/08 v1.3 Providing info/warning/error messages (HO)
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\oberdiek\ltxcmds.sty"
+Package: ltxcmds 2011/11/09 v1.22 LaTeX kernel commands for general use (HO)
+)
+\Gread@gobject=\count112
+))
+("C:\Program Files (x86)\MiKTeX\tex\latex\geometry\geometry.sty"
+Package: geometry 2010/09/12 v5.6 Page Geometry
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\graphics\keyval.sty"
+Package: keyval 1999/03/16 v1.13 key=value parser (DPC)
+\KV@toks@=\toks15
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\oberdiek\ifpdf.sty"
+Package: ifpdf 2011/01/30 v2.3 Provides the ifpdf switch (HO)
+Package ifpdf Info: pdfTeX in PDF mode is detected.
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\oberdiek\ifvtex.sty"
+Package: ifvtex 2010/03/01 v1.5 Detect VTeX and its facilities (HO)
+Package ifvtex Info: VTeX not detected.
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\ifxetex\ifxetex.sty"
+Package: ifxetex 2010/09/12 v0.6 Provides ifxetex conditional
+)
+\Gm@cnth=\count113
+\Gm@cntv=\count114
+\c@Gm@tempcnt=\count115
+\Gm@bindingoffset=\dimen126
+\Gm@wd@mp=\dimen127
+\Gm@odd@mp=\dimen128
+\Gm@even@mp=\dimen129
+\Gm@layoutwidth=\dimen130
+\Gm@layoutheight=\dimen131
+\Gm@layouthoffset=\dimen132
+\Gm@layoutvoffset=\dimen133
+\Gm@dimlist=\toks16
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\geometry\geometry.cfg"))
+("C:\Program Files (x86)\MiKTeX\tex\latex\graphics\graphicx.sty"
+Package: graphicx 1999/02/16 v1.0f Enhanced LaTeX Graphics (DPC,SPQR)
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\graphics\graphics.sty"
+Package: graphics 2009/02/05 v1.0o Standard LaTeX Graphics (DPC,SPQR)
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\graphics\trig.sty"
+Package: trig 1999/03/16 v1.09 sin cos tan (DPC)
+)
+("C:\Program Files (x86)\MiKTeX\tex\latex\00miktex\graphics.cfg"
+File: graphics.cfg 2007/01/18 v1.5 graphics configuration of teTeX/TeXLive
+)
+Package graphics Info: Driver file: pdftex.def on input line 91.
+)
+\Gin@req@height=\dimen134
+\Gin@req@width=\dimen135
+)
+("C:\Program Files (x86)\MiKTeX\tex\latex\listings\listings.sty"
+\lst@mode=\count116
+\lst@gtempboxa=\box28
+\lst@token=\toks17
+\lst@length=\count117
+\lst@currlwidth=\dimen136
+\lst@column=\count118
+\lst@pos=\count119
+\lst@lostspace=\dimen137
+\lst@width=\dimen138
+\lst@newlines=\count120
+\lst@lineno=\count121
+\lst@maxwidth=\dimen139
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\listings\lstmisc.sty"
+File: lstmisc.sty 2014/09/06 1.5e (Carsten Heinz)
+\c@lstnumber=\count122
+\lst@skipnumbers=\count123
+\lst@framebox=\box29
+)
+("C:\Program Files (x86)\MiKTeX\tex\latex\listings\listings.cfg"
+File: listings.cfg 2014/09/06 1.5e listings configuration
+))
+Package: listings 2014/09/06 1.5e (Carsten Heinz)
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\pgf\frontendlayer\tikz.sty"
+("C:\Program Files (x86)\MiKTeX\tex\latex\pgf\basiclayer\pgf.sty"
+("C:\Program Files (x86)\MiKTeX\tex\latex\pgf\utilities\pgfrcs.sty"
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\utilities\pgfutil-common.tex"
+\pgfutil@everybye=\toks18
+\pgfutil@tempdima=\dimen140
+\pgfutil@tempdimb=\dimen141
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\utilities\pgfutil-common-lists.
+tex"))
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\utilities\pgfutil-latex.def"
+\pgfutil@abb=\box30
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\ms\everyshi.sty"
+Package: everyshi 2001/05/15 v3.00 EveryShipout Package (MS)
+))
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\utilities\pgfrcs.code.tex"
+Package: pgfrcs 2013/12/20 v3.0.0 (rcs-revision 1.28)
+))
+Package: pgf 2013/12/18 v3.0.0 (rcs-revision 1.14)
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\pgf\basiclayer\pgfcore.sty"
+("C:\Program Files (x86)\MiKTeX\tex\latex\pgf\systemlayer\pgfsys.sty"
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\systemlayer\pgfsys.code.tex"
+Package: pgfsys 2013/11/30 v3.0.0 (rcs-revision 1.47)
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\utilities\pgfkeys.code.tex"
+\pgfkeys@pathtoks=\toks19
+\pgfkeys@temptoks=\toks20
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\utilities\pgfkeysfiltered.code.
+tex"
+\pgfkeys@tmptoks=\toks21
+))
+\pgf@x=\dimen142
+\pgf@y=\dimen143
+\pgf@xa=\dimen144
+\pgf@ya=\dimen145
+\pgf@xb=\dimen146
+\pgf@yb=\dimen147
+\pgf@xc=\dimen148
+\pgf@yc=\dimen149
+\w@pgf@writea=\write3
+\r@pgf@reada=\read1
+\c@pgf@counta=\count124
+\c@pgf@countb=\count125
+\c@pgf@countc=\count126
+\c@pgf@countd=\count127
+\t@pgf@toka=\toks22
+\t@pgf@tokb=\toks23
+\t@pgf@tokc=\toks24
+ ("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\systemlayer\pgf.cfg"
+File: pgf.cfg 2008/05/14  (rcs-revision 1.7)
+)
+Driver file for pgf: pgfsys-pdftex.def
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\systemlayer\pgfsys-pdftex.def"
+File: pgfsys-pdftex.def 2013/07/18  (rcs-revision 1.33)
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\systemlayer\pgfsys-common-pdf.d
+ef"
+File: pgfsys-common-pdf.def 2013/10/10  (rcs-revision 1.13)
+)))
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\systemlayer\pgfsyssoftpath.code
+.tex"
+File: pgfsyssoftpath.code.tex 2013/09/09  (rcs-revision 1.9)
+\pgfsyssoftpath@smallbuffer@items=\count128
+\pgfsyssoftpath@bigbuffer@items=\count129
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\systemlayer\pgfsysprotocol.code
+.tex"
+File: pgfsysprotocol.code.tex 2006/10/16  (rcs-revision 1.4)
+)) ("C:\Program Files (x86)\MiKTeX\tex\latex\xcolor\xcolor.sty"
+Package: xcolor 2007/01/21 v2.11 LaTeX color extensions (UK)
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\00miktex\color.cfg"
+File: color.cfg 2007/01/18 v1.5 color configuration of teTeX/TeXLive
+)
+Package xcolor Info: Driver file: pdftex.def on input line 225.
+LaTeX Info: Redefining \color on input line 702.
+Package xcolor Info: Model `cmy' substituted by `cmy0' on input line 1337.
+Package xcolor Info: Model `hsb' substituted by `rgb' on input line 1341.
+Package xcolor Info: Model `RGB' extended on input line 1353.
+Package xcolor Info: Model `HTML' substituted by `rgb' on input line 1355.
+Package xcolor Info: Model `Hsb' substituted by `hsb' on input line 1356.
+Package xcolor Info: Model `tHsb' substituted by `hsb' on input line 1357.
+Package xcolor Info: Model `HSB' substituted by `hsb' on input line 1358.
+Package xcolor Info: Model `Gray' substituted by `gray' on input line 1359.
+Package xcolor Info: Model `wave' substituted by `hsb' on input line 1360.
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\basiclayer\pgfcore.code.tex"
+Package: pgfcore 2010/04/11 v3.0.0 (rcs-revision 1.7)
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\math\pgfmath.code.tex"
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\math\pgfmathcalc.code.tex"
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\math\pgfmathutil.code.tex")
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\math\pgfmathparser.code.tex"
+\pgfmath@dimen=\dimen150
+\pgfmath@count=\count130
+\pgfmath@box=\box31
+\pgfmath@toks=\toks25
+\pgfmath@stack@operand=\toks26
+\pgfmath@stack@operation=\toks27
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\math\pgfmathfunctions.code.tex"
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\math\pgfmathfunctions.basic.cod
+e.tex")
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\math\pgfmathfunctions.trigonome
+tric.code.tex")
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\math\pgfmathfunctions.random.co
+de.tex")
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\math\pgfmathfunctions.compariso
+n.code.tex")
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\math\pgfmathfunctions.base.code
+.tex")
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\math\pgfmathfunctions.round.cod
+e.tex")
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\math\pgfmathfunctions.misc.code
+.tex")
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\math\pgfmathfunctions.integerar
+ithmetics.code.tex")))
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\math\pgfmathfloat.code.tex"
+\c@pgfmathroundto@lastzeros=\count131
+))
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\basiclayer\pgfcorepoints.code.t
+ex"
+File: pgfcorepoints.code.tex 2013/10/07  (rcs-revision 1.27)
+\pgf@picminx=\dimen151
+\pgf@picmaxx=\dimen152
+\pgf@picminy=\dimen153
+\pgf@picmaxy=\dimen154
+\pgf@pathminx=\dimen155
+\pgf@pathmaxx=\dimen156
+\pgf@pathminy=\dimen157
+\pgf@pathmaxy=\dimen158
+\pgf@xx=\dimen159
+\pgf@xy=\dimen160
+\pgf@yx=\dimen161
+\pgf@yy=\dimen162
+\pgf@zx=\dimen163
+\pgf@zy=\dimen164
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\basiclayer\pgfcorepathconstruct
+.code.tex"
+File: pgfcorepathconstruct.code.tex 2013/10/07  (rcs-revision 1.29)
+\pgf@path@lastx=\dimen165
+\pgf@path@lasty=\dimen166
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\basiclayer\pgfcorepathusage.cod
+e.tex"
+File: pgfcorepathusage.code.tex 2013/12/13  (rcs-revision 1.23)
+\pgf@shorten@end@additional=\dimen167
+\pgf@shorten@start@additional=\dimen168
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\basiclayer\pgfcorescopes.code.t
+ex"
+File: pgfcorescopes.code.tex 2013/10/09  (rcs-revision 1.44)
+\pgfpic=\box32
+\pgf@hbox=\box33
+\pgf@layerbox@main=\box34
+\pgf@picture@serial@count=\count132
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\basiclayer\pgfcoregraphicstate.
+code.tex"
+File: pgfcoregraphicstate.code.tex 2013/09/19  (rcs-revision 1.11)
+\pgflinewidth=\dimen169
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\basiclayer\pgfcoretransformatio
+ns.code.tex"
+File: pgfcoretransformations.code.tex 2013/10/10  (rcs-revision 1.17)
+\pgf@pt@x=\dimen170
+\pgf@pt@y=\dimen171
+\pgf@pt@temp=\dimen172
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\basiclayer\pgfcorequick.code.te
+x"
+File: pgfcorequick.code.tex 2008/10/09  (rcs-revision 1.3)
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\basiclayer\pgfcoreobjects.code.
+tex"
+File: pgfcoreobjects.code.tex 2006/10/11  (rcs-revision 1.2)
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\basiclayer\pgfcorepathprocessin
+g.code.tex"
+File: pgfcorepathprocessing.code.tex 2013/09/09  (rcs-revision 1.9)
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\basiclayer\pgfcorearrows.code.t
+ex"
+File: pgfcorearrows.code.tex 2013/11/07  (rcs-revision 1.40)
+\pgfarrowsep=\dimen173
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\basiclayer\pgfcoreshade.code.te
+x"
+File: pgfcoreshade.code.tex 2013/07/15  (rcs-revision 1.15)
+\pgf@max=\dimen174
+\pgf@sys@shading@range@num=\count133
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\basiclayer\pgfcoreimage.code.te
+x"
+File: pgfcoreimage.code.tex 2013/07/15  (rcs-revision 1.18)
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\basiclayer\pgfcoreexternal.code
+.tex"
+File: pgfcoreexternal.code.tex 2013/07/15  (rcs-revision 1.20)
+\pgfexternal@startupbox=\box35
+))
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\basiclayer\pgfcorelayers.code.t
+ex"
+File: pgfcorelayers.code.tex 2013/07/18  (rcs-revision 1.7)
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\basiclayer\pgfcoretransparency.
+code.tex"
+File: pgfcoretransparency.code.tex 2013/09/30  (rcs-revision 1.5)
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\basiclayer\pgfcorepatterns.code
+.tex"
+File: pgfcorepatterns.code.tex 2013/11/07  (rcs-revision 1.5)
+)))
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\modules\pgfmoduleshapes.code.te
+x"
+File: pgfmoduleshapes.code.tex 2013/10/31  (rcs-revision 1.34)
+\pgfnodeparttextbox=\box36
+)
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\modules\pgfmoduleplot.code.tex"
+File: pgfmoduleplot.code.tex 2013/07/31  (rcs-revision 1.12)
+)
+("C:\Program Files (x86)\MiKTeX\tex\latex\pgf\compatibility\pgfcomp-version-0-6
+5.sty"
+Package: pgfcomp-version-0-65 2007/07/03 v3.0.0 (rcs-revision 1.7)
+\pgf@nodesepstart=\dimen175
+\pgf@nodesepend=\dimen176
+)
+("C:\Program Files (x86)\MiKTeX\tex\latex\pgf\compatibility\pgfcomp-version-1-1
+8.sty"
+Package: pgfcomp-version-1-18 2007/07/23 v3.0.0 (rcs-revision 1.1)
+)) ("C:\Program Files (x86)\MiKTeX\tex\latex\pgf\utilities\pgffor.sty"
+("C:\Program Files (x86)\MiKTeX\tex\latex\pgf\utilities\pgfkeys.sty"
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\utilities\pgfkeys.code.tex"))
+("C:\Program Files (x86)\MiKTeX\tex\latex\pgf\math\pgfmath.sty"
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\math\pgfmath.code.tex"))
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\utilities\pgffor.code.tex"
+Package: pgffor 2013/12/13 v3.0.0 (rcs-revision 1.25)
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\math\pgfmath.code.tex")
+\pgffor@iter=\dimen177
+\pgffor@skip=\dimen178
+\pgffor@stack=\toks28
+\pgffor@toks=\toks29
+))
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\frontendlayer\tikz\tikz.code.te
+x"
+Package: tikz 2013/12/13 v3.0.0 (rcs-revision 1.142)
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\libraries\pgflibraryplothandler
+s.code.tex"
+File: pgflibraryplothandlers.code.tex 2013/08/31 v3.0.0 (rcs-revision 1.20)
+\pgf@plot@mark@count=\count134
+\pgfplotmarksize=\dimen179
+)
+\tikz@lastx=\dimen180
+\tikz@lasty=\dimen181
+\tikz@lastxsaved=\dimen182
+\tikz@lastysaved=\dimen183
+\tikzleveldistance=\dimen184
+\tikzsiblingdistance=\dimen185
+\tikz@figbox=\box37
+\tikz@figbox@bg=\box38
+\tikz@tempbox=\box39
+\tikz@tempbox@bg=\box40
+\tikztreelevel=\count135
+\tikznumberofchildren=\count136
+\tikznumberofcurrentchild=\count137
+\tikz@fig@count=\count138
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\modules\pgfmodulematrix.code.te
+x"
+File: pgfmodulematrix.code.tex 2013/09/17  (rcs-revision 1.8)
+\pgfmatrixcurrentrow=\count139
+\pgfmatrixcurrentcolumn=\count140
+\pgf@matrix@numberofcolumns=\count141
+)
+\tikz@expandcount=\count142
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\frontendlayer\tikz\libraries\ti
+kzlibrarytopaths.code.tex"
+File: tikzlibrarytopaths.code.tex 2008/06/17 v3.0.0 (rcs-revision 1.2)
+)))
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\frontendlayer\tikz\libraries\ti
+kzlibraryshapes.code.tex"
+File: tikzlibraryshapes.code.tex 2008/01/09 v3.0.0 (rcs-revision 1.1)
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\frontendlayer\tikz\libraries\ti
+kzlibraryshapes.geometric.code.tex"
+File: tikzlibraryshapes.geometric.code.tex 2008/01/09 v3.0.0 (rcs-revision 1.1)
+
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\libraries\shapes\pgflibraryshap
+es.geometric.code.tex"
+File: pgflibraryshapes.geometric.code.tex 2008/06/26 v3.0.0 (rcs-revision 1.1)
+))
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\frontendlayer\tikz\libraries\ti
+kzlibraryshapes.misc.code.tex"
+File: tikzlibraryshapes.misc.code.tex 2008/01/09 v3.0.0 (rcs-revision 1.1)
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\libraries\shapes\pgflibraryshap
+es.misc.code.tex"
+File: pgflibraryshapes.misc.code.tex 2013/07/18 v3.0.0 (rcs-revision 1.5)
+))
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\frontendlayer\tikz\libraries\ti
+kzlibraryshapes.symbols.code.tex"
+File: tikzlibraryshapes.symbols.code.tex 2008/01/09 v3.0.0 (rcs-revision 1.1)
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\libraries\shapes\pgflibraryshap
+es.symbols.code.tex"
+File: pgflibraryshapes.symbols.code.tex 2013/09/11 v3.0.0 (rcs-revision 1.6)
+))
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\frontendlayer\tikz\libraries\ti
+kzlibraryshapes.arrows.code.tex"
+File: tikzlibraryshapes.arrows.code.tex 2008/01/09 v3.0.0 (rcs-revision 1.1)
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\libraries\shapes\pgflibraryshap
+es.arrows.code.tex"
+File: pgflibraryshapes.arrows.code.tex 2008/06/26 v3.0.0 (rcs-revision 1.1)
+))
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\frontendlayer\tikz\libraries\ti
+kzlibraryshapes.callouts.code.tex"
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\libraries\shapes\pgflibraryshap
+es.callouts.code.tex"))
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\frontendlayer\tikz\libraries\ti
+kzlibraryshapes.multipart.code.tex"
+File: tikzlibraryshapes.multipart.code.tex 2008/01/09 v3.0.0 (rcs-revision 1.1)
+
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\libraries\shapes\pgflibraryshap
+es.multipart.code.tex"
+File: pgflibraryshapes.multipart.code.tex 2010/01/07 v3.0.0 (rcs-revision 1.2)
+\pgfnodepartlowerbox=\box41
+\pgfnodeparttwobox=\box42
+\pgfnodepartthreebox=\box43
+\pgfnodepartfourbox=\box44
+\pgfnodeparttwentybox=\box45
+\pgfnodepartnineteenbox=\box46
+\pgfnodeparteighteenbox=\box47
+\pgfnodepartseventeenbox=\box48
+\pgfnodepartsixteenbox=\box49
+\pgfnodepartfifteenbox=\box50
+\pgfnodepartfourteenbox=\box51
+\pgfnodepartthirteenbox=\box52
+\pgfnodeparttwelvebox=\box53
+\pgfnodepartelevenbox=\box54
+\pgfnodeparttenbox=\box55
+\pgfnodepartninebox=\box56
+\pgfnodeparteightbox=\box57
+\pgfnodepartsevenbox=\box58
+\pgfnodepartsixbox=\box59
+\pgfnodepartfivebox=\box60
+)))
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\frontendlayer\tikz\libraries\ti
+kzlibraryarrows.code.tex"
+File: tikzlibraryarrows.code.tex 2008/01/09 v3.0.0 (rcs-revision 1.1)
+
+("C:\Program Files (x86)\MiKTeX\tex\generic\pgf\libraries\pgflibraryarrows.code
+.tex"
+File: pgflibraryarrows.code.tex 2013/09/23 v3.0.0 (rcs-revision 1.16)
+\arrowsize=\dimen186
+)) ("C:\Program Files (x86)\MiKTeX\tex\latex\wrapfig\wrapfig.sty"
+\wrapoverhang=\dimen187
+\WF@size=\dimen188
+\c@WF@wrappedlines=\count143
+\WF@box=\box61
+\WF@everypar=\toks30
+Package: wrapfig 2003/01/31  v 3.6
+)
+("C:\Program Files (x86)\MiKTeX\tex\latex\cite\cite.sty"
+LaTeX Info: Redefining \cite on input line 302.
+LaTeX Info: Redefining \nocite on input line 332.
+Package: cite 2015/02/27  v 5.5
+)
+("C:\Program Files (x86)\MiKTeX\tex\latex\amsmath\amsmath.sty"
+Package: amsmath 2013/01/14 v2.14 AMS math features
+\@mathmargin=\skip44
+
+For additional information on amsmath, use the `?' option.
+("C:\Program Files (x86)\MiKTeX\tex\latex\amsmath\amstext.sty"
+Package: amstext 2000/06/29 v2.01
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\amsmath\amsgen.sty"
+File: amsgen.sty 1999/11/30 v2.0
+\@emptytoks=\toks31
+\ex@=\dimen189
+))
+("C:\Program Files (x86)\MiKTeX\tex\latex\amsmath\amsbsy.sty"
+Package: amsbsy 1999/11/29 v1.2d
+\pmbraise@=\dimen190
+)
+("C:\Program Files (x86)\MiKTeX\tex\latex\amsmath\amsopn.sty"
+Package: amsopn 1999/12/14 v2.01 operator names
+)
+\inf@bad=\count144
+LaTeX Info: Redefining \frac on input line 210.
+\uproot@=\count145
+\leftroot@=\count146
+LaTeX Info: Redefining \overline on input line 306.
+\classnum@=\count147
+\DOTSCASE@=\count148
+LaTeX Info: Redefining \ldots on input line 378.
+LaTeX Info: Redefining \dots on input line 381.
+LaTeX Info: Redefining \cdots on input line 466.
+\Mathstrutbox@=\box62
+\strutbox@=\box63
+\big@size=\dimen191
+LaTeX Font Info:    Redeclaring font encoding OML on input line 566.
+LaTeX Font Info:    Redeclaring font encoding OMS on input line 567.
+\macc@depth=\count149
+\c@MaxMatrixCols=\count150
+\dotsspace@=\muskip10
+\c@parentequation=\count151
+\dspbrk@lvl=\count152
+\tag@help=\toks32
+\row@=\count153
+\column@=\count154
+\maxfields@=\count155
+\andhelp@=\toks33
+\eqnshift@=\dimen192
+\alignsep@=\dimen193
+\tagshift@=\dimen194
+\tagwidth@=\dimen195
+\totwidth@=\dimen196
+\lineht@=\dimen197
+\@envbody=\toks34
+\multlinegap=\skip45
+\multlinetaggap=\skip46
+\mathdisplay@stack=\toks35
+LaTeX Info: Redefining \[ on input line 2665.
+LaTeX Info: Redefining \] on input line 2666.
+)
+("C:\Program Files (x86)\MiKTeX\tex\latex\algorithms\algorithm.sty"
+Package: algorithm 2009/08/24 v0.1 Document Style `algorithm' - floating enviro
+nment
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\float\float.sty"
+Package: float 2001/11/08 v1.3d Float enhancements (AL)
+\c@float@type=\count156
+\float@exts=\toks36
+\float@box=\box64
+\@float@everytoks=\toks37
+\@floatcapt=\box65
+)
+("C:\Program Files (x86)\MiKTeX\tex\latex\base\ifthen.sty"
+Package: ifthen 2001/05/26 v1.1c Standard LaTeX ifthen package (DPC)
+)
+\@float@every@algorithm=\toks38
+\c@algorithm=\count157
+)
+("C:\Program Files (x86)\MiKTeX\tex\latex\algorithms\algorithmic.sty"
+Package: algorithmic 2009/08/24 v0.1 Document Style `algorithmic'
+\c@ALC@unique=\count158
+\c@ALC@line=\count159
+\c@ALC@rem=\count160
+\c@ALC@depth=\count161
+\ALC@tlm=\skip47
+\algorithmicindent=\skip48
+)
+("C:\Program Files (x86)\MiKTeX\tex\latex\amsfonts\amssymb.sty"
+Package: amssymb 2013/01/14 v3.01 AMS font symbols
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\amsfonts\amsfonts.sty"
+Package: amsfonts 2013/01/14 v3.01 Basic AMSFonts support
+\symAMSa=\mathgroup4
+\symAMSb=\mathgroup5
+LaTeX Font Info:    Overwriting math alphabet `\mathfrak' in version `bold'
+(Font)                  U/euf/m/n --> U/euf/b/n on input line 106.
+))
+(Z:\scc300\report\final-report.aux)
+LaTeX Font Info:    Checking defaults for OML/cmm/m/it on input line 81.
+LaTeX Font Info:    ... okay on input line 81.
+LaTeX Font Info:    Checking defaults for T1/cmr/m/n on input line 81.
+LaTeX Font Info:    ... okay on input line 81.
+LaTeX Font Info:    Checking defaults for OT1/cmr/m/n on input line 81.
+LaTeX Font Info:    ... okay on input line 81.
+LaTeX Font Info:    Checking defaults for OMS/cmsy/m/n on input line 81.
+LaTeX Font Info:    ... okay on input line 81.
+LaTeX Font Info:    Checking defaults for OMX/cmex/m/n on input line 81.
+LaTeX Font Info:    ... okay on input line 81.
+LaTeX Font Info:    Checking defaults for U/cmr/m/n on input line 81.
+LaTeX Font Info:    ... okay on input line 81.
+
+-- Lines per column: 50 (approximate, difference = 8.53687pt).
+("C:\Program Files (x86)\MiKTeX\tex\context\base\supp-pdf.mkii"
+[Loading MPS to PDF converter (version 2006.09.02).]
+\scratchcounter=\count162
+\scratchdimen=\dimen198
+\scratchbox=\box66
+\nofMPsegments=\count163
+\nofMParguments=\count164
+\everyMPshowfont=\toks39
+\MPscratchCnt=\count165
+\MPscratchDim=\dimen199
+\MPnumerator=\count166
+\makeMPintoPDFobject=\count167
+\everyMPtoPDFconversion=\toks40
+)
+*geometry* driver: auto-detecting
+*geometry* detected driver: pdftex
+*geometry* verbose mode - [ preamble ] result:
+* driver: pdftex
+* paper: a4paper
+* layout: <same size as paper>
+* layoutoffset:(h,v)=(0.0pt,0.0pt)
+* modes: 
+* h-part:(L,W,R)=(56.9055pt, 483.69687pt, 56.9055pt)
+* v-part:(T,H,B)=(56.9055pt, 731.23584pt, 56.9055pt)
+* \paperwidth=597.50787pt
+* \paperheight=845.04684pt
+* \textwidth=483.69687pt
+* \textheight=731.23584pt
+* \oddsidemargin=-15.36449pt
+* \evensidemargin=-15.36449pt
+* \topmargin=-35.81992pt
+* \headheight=12.0pt
+* \headsep=8.45543pt
+* \topskip=14.45398pt
+* \footskip=23.45547pt
+* \marginparwidth=20.0pt
+* \marginparsep=10.0pt
+* \columnsep=12.045pt
+* \skip\footins=13.00848pt plus 5.7815pt minus 2.89075pt
+* \hoffset=0.0pt
+* \voffset=0.0pt
+* \mag=1000
+* \@twocolumntrue
+* \@twosidefalse
+* \@mparswitchfalse
+* \@reversemarginfalse
+* (1in=72.27pt=25.4mm, 1cm=28.453pt)
+
+\c@lstlisting=\count168
+ABD: EveryShipout initializing macros
+LaTeX Font Info:    Try loading font information for OT1+phv on input line 87.
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\psnfss\ot1phv.fd"
+File: ot1phv.fd 2001/06/04 scalable font definitions for OT1/phv.
+)
+LaTeX Font Info:    Calculating math sizes for size <14.05249> on input line 87
+.
+LaTeX Font Info:    Try loading font information for U+msa on input line 87.
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\amsfonts\umsa.fd"
+File: umsa.fd 2013/01/14 v3.01 AMS symbols A
+)
+LaTeX Font Info:    Try loading font information for U+msb on input line 87.
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\amsfonts\umsb.fd"
+File: umsb.fd 2013/01/14 v3.01 AMS symbols B
+)
+LaTeX Font Info:    Try loading font information for U+pzd on input line 87.
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\psnfss\upzd.fd"
+File: upzd.fd 2001/06/04 font definitions for U/pzd.
+) [1{C:/Users/Rumps/AppData/Local/MiKTeX/2.9/pdftex/config/pdftex.map}
+
+
+
+]
+LaTeX Font Info:    Font shape `OT1/phv/bx/n' in size <14.05249> not available
+(Font)              Font shape `OT1/phv/b/n' tried instead on input line 91.
+LaTeX Font Info:    Font shape `OT1/phv/bx/sc' in size <14.05249> not available
+
+(Font)              Font shape `OT1/phv/b/sc' tried instead on input line 91.
+LaTeX Font Info:    Try loading font information for OT1+pcr on input line 95.
+
+("C:\Program Files (x86)\MiKTeX\tex\latex\psnfss\ot1pcr.fd"
+File: ot1pcr.fd 2001/06/04 font definitions for OT1/pcr.
+)
+Underfull \hbox (badness 10000) in paragraph at lines 93--98
+\OT1/ppl/m/n/12.045 All work-ing doc-u-ments and re-sults can be found at
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 93--98
+
+ []
+
+[2
+
+]
+LaTeX Font Info:    Font shape `OT1/phv/bx/n' in size <9.03374> not available
+(Font)              Font shape `OT1/phv/b/n' tried instead on input line 102.
+ [3]
+LaTeX Font Info:    Calculating math sizes for size <12.045> on input line 140.
+
+ [4] [5] [6]
+LaTeX Font Info:    Font shape `OT1/phv/bx/n' in size <12.045> not available
+(Font)              Font shape `OT1/phv/b/n' tried instead on input line 169.
+
+Underfull \hbox (badness 10000) in paragraph at lines 171--172
+
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 173--174
+
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 175--176
+
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 177--178
+
+ []
+
+[7]
+LaTeX Font Info:    Try loading font information for OMS+ppl on input line 191.
+
+ ("C:\Program Files (x86)\MiKTeX\tex\latex\psnfss\omsppl.fd"
+File: omsppl.fd 
+)
+LaTeX Font Info:    Font shape `OMS/ppl/m/n' in size <9.03374> not available
+(Font)              Font shape `OMS/cmsy/m/n' tried instead on input line 191.
+ [8] [9]
+LaTeX Font Info:    Font shape `OMS/ppl/m/n' in size <12.045> not available
+(Font)              Font shape `OMS/cmsy/m/n' tried instead on input line 206.
+
+Underfull \hbox (badness 10000) in paragraph at lines 210--213
+
+ []
+
+
+Overfull \hbox (16.83781pt too wide) in paragraph at lines 216--216
+ [][][][]\OT1/ppl/m/n/12.045 EmerGen(e)tic 
+ []
+
+LaTeX Font Info:    Font shape `OT1/phv/m/it' in size <12.045> not available
+(Font)              Font shape `OT1/phv/m/sl' tried instead on input line 230.
+
+Underfull \hbox (badness 10000) in paragraph at lines 232--233
+
+ []
+
+[10] [11] ("C:\Program Files (x86)\MiKTeX\tex\latex\listings\lstlang1.sty"
+File: lstlang1.sty 2014/09/06 1.5e listings language file
+)
+Underfull \hbox (badness 10000) in paragraph at lines 285--287
+
+ []
+
+[12]
+Underfull \hbox (badness 10000) in paragraph at lines 288--289
+
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 297--298
+
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 299--300
+
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 309--311
+
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 312--313
+
+ []
+
+[13]
+LaTeX Font Info:    Font shape `OT1/phv/bx/n' in size <10.03749> not available
+(Font)              Font shape `OT1/phv/b/n' tried instead on input line 334.
+LaTeX Font Info:    Font shape `OT1/pcr/bx/n' in size <10.03749> not available
+(Font)              Font shape `OT1/pcr/b/n' tried instead on input line 334.
+LaTeX Font Info:    Font shape `OT1/phv/m/it' in size <10.03749> not available
+(Font)              Font shape `OT1/phv/m/sl' tried instead on input line 338.
+LaTeX Font Info:    Font shape `OT1/pcr/m/it' in size <10.03749> not available
+(Font)              Font shape `OT1/pcr/m/sl' tried instead on input line 338.
+ [14]
+LaTeX Font Info:    Font shape `OT1/phv/bx/sc' in size <10.03749> not available
+
+(Font)              Font shape `OT1/phv/b/sc' tried instead on input line 357.
+LaTeX Font Info:    Font shape `OT1/pcr/bx/sc' in size <10.03749> not available
+
+(Font)              Font shape `OT1/pcr/b/sc' tried instead on input line 357.
+ [15]
+Underfull \hbox (badness 10000) in paragraph at lines 420--421
+\OT1/ppl/m/n/12.045 Within the [][][][] method,[] the [][][] com-po-nent within
+
+ []
+
+[16] ("C:\Program Files (x86)\MiKTeX\tex\latex\listings\lstlang1.sty"
+File: lstlang1.sty 2014/09/06 1.5e listings language file
+)
+Underfull \hbox (badness 2435) in paragraph at lines 445--446
+\OT1/ppl/m/n/12.045 If the python script is called with a gen-er-a-tion ar-gu-m
+ent of `0' it calls the
+ []
+
+[17] ("C:\Program Files (x86)\MiKTeX\tex\latex\listings\lstlang1.sty"
+File: lstlang1.sty 2014/09/06 1.5e listings language file
+)
+("C:\Program Files (x86)\MiKTeX\tex\latex\listings\lstlang1.sty"
+File: lstlang1.sty 2014/09/06 1.5e listings language file
+) [18]
+Underfull \vbox (badness 10000) has occurred while \output is active []
+
+ [19]
+[20] (Z:\scc300\dat\helloworld\output50.txt)
+(Z:\scc300\dat\helloworld\output50.txt) (Z:\scc300\dat\helloworld\output0.txt
+[21]) (Z:\scc300\dat\helloworld\output0.txt)
+(Z:\scc300\dat\helloworld\output100.txt)
+(Z:\scc300\dat\helloworld\output100.txt)
+Underfull \hbox (badness 10000) in paragraph at lines 614--616
+
+ []
+
+<./img/difffile-large.PNG, id=91, 455.45157pt x 255.95625pt>
+File: ./img/difffile-large.PNG Graphic file (type png)
+
+<use ./img/difffile-large.PNG>
+Package pdftex.def Info: ./img/difffile-large.PNG used on input line 623.
+(pdftex.def)             Requested size: 212.82779pt x 119.60815pt.
+
+<./img/difffile-large-wo.PNG, id=92, 455.45157pt x 255.95625pt>
+File: ./img/difffile-large-wo.PNG Graphic file (type png)
+
+<use ./img/difffile-large-wo.PNG>
+Package pdftex.def Info: ./img/difffile-large-wo.PNG used on input line 627.
+(pdftex.def)             Requested size: 212.82779pt x 119.60815pt.
+
+<./img/samefile-images.PNG, id=93, 455.45157pt x 255.95625pt>
+File: ./img/samefile-images.PNG Graphic file (type png)
+
+<use ./img/samefile-images.PNG>
+Package pdftex.def Info: ./img/samefile-images.PNG used on input line 631.
+(pdftex.def)             Requested size: 212.82779pt x 119.60815pt.
+
+<./img/samefile-images-wo.PNG, id=94, 455.45157pt x 255.95625pt>
+File: ./img/samefile-images-wo.PNG Graphic file (type png)
+
+<use ./img/samefile-images-wo.PNG>
+Package pdftex.def Info: ./img/samefile-images-wo.PNG used on input line 635.
+(pdftex.def)             Requested size: 212.82779pt x 119.60815pt.
+ [22]
+
+Package wrapfig Warning: wrapfigure used inside a conflicting environment on in
+put line 643.
+
+
+Package wrapfig Warning: wrapfigure used inside a conflicting environment on in
+put line 644.
+
+
+Package wrapfig Warning: wrapfigure used inside a conflicting environment on in
+put line 646.
+
+
+Package wrapfig Warning: wrapfigure used inside a conflicting environment on in
+put line 646.
+
+
+Package wrapfig Warning: wrapfigure used inside a conflicting environment on in
+put line 646.
+
+
+Package wrapfig Warning: wrapfigure used inside a conflicting environment on in
+put line 646.
+
+
+Package wrapfig Warning: wrapfigure used inside a conflicting environment on in
+put line 647.
+
+
+Underfull \hbox (badness 4254) in paragraph at lines 642--649
+\OT1/ppl/m/n/12.045 Tests were then run on the test suite
+ []
+
+[23 <Z:/scc300/report/img/difffile-large.PNG (PNG copy)> <Z:/scc300/report/img/
+difffile-large-wo.PNG (PNG copy)> <Z:/scc300/report/img/samefile-images.PNG (PN
+G copy)> <Z:/scc300/report/img/samefile-images-wo.PNG (PNG copy)>] [24]
+Underfull \hbox (badness 10000) in paragraph at lines 664--665
+
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 666--667
+
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 668--669
+
+ []
+
+
+Underfull \hbox (badness 10000) in paragraph at lines 670--671
+
+ []
+
+[25] [26] (Z:\scc300\report\final-report.bbl
+LaTeX Font Info:    Calculating math sizes for size <9.03374> on input line 100
+.
+) [27]
+(Z:\scc300\src\emergenetic\emergenetic.dn
+Missing character: There is no  in font pcrr7t!
+Missing character: There is no © in font pcrr7t!
+ [28]
+Underfull \vbox (badness 10000) has occurred while \output is active []
+
+ [29]
+Overfull \hbox (9.06848pt too wide) in paragraph at lines 157--158
+[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][
+][][][][][][][][][][][][][][][][][][][][][][][][][][][][] 
+ []
+
+
+Overfull \hbox (181.78821pt too wide) in paragraph at lines 159--160
+[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][
+][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
+[][][][][][][][][][][][][][][][][][][][][][][][][][][][]  
+ []
+
+
+Underfull \vbox (badness 10000) has occurred while \output is active []
+
+ [30])
+[31] (Z:\scc300\src\helloworld\project\helloworld\mutator.py
+Overfull \hbox (61.7654pt too wide) in paragraph at lines 47--48
+[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][
+][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
+[][][] 
+ []
+
+
+Overfull \hbox (61.7654pt too wide) in paragraph at lines 52--53
+[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][
+][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
+[][][] 
+ []
+
+[32]) [33] (Z:\scc300\src\cachingpolicy\cachebackup\CacheHandlerBase.dn
+Missing character: There is no  in font pcrr7t!
+Missing character: There is no © in font pcrr7t!
+
+[34]
+Underfull \vbox (badness 10000) has occurred while \output is active []
+
+ [35]
+Underfull \vbox (badness 10000) has occurred while \output is active []
+
+ [36]
+Underfull \vbox (badness 10000) has occurred while \output is active []
+
+ [37])
+[38] (Z:\scc300\src\cachingpolicy\project\cachingpolicy\mutator.py [39]
+Underfull \vbox (badness 10000) has occurred while \output is active []
+
+ [40]
+Underfull \vbox (badness 10000) has occurred while \output is active []
+
+ [41]
+Overfull \hbox (37.67543pt too wide) in paragraph at lines 218--219
+[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][
+][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
+[][][] 
+ []
+
+
+Overfull \hbox (31.65294pt too wide) in paragraph at lines 225--226
+[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][
+][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
+[][][][]  
+ []
+
+
+Overfull \hbox (67.78789pt too wide) in paragraph at lines 226--227
+[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][
+][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
+[][][][][][][][][] 
+ []
+
+
+Overfull \hbox (51.22592pt too wide) in paragraph at lines 227--228
+[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][
+][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
+[][][] 
+ []
+
+
+Underfull \vbox (badness 10000) has occurred while \output is active []
+
+ [42]
+Overfull \hbox (71.87785pt too wide) in paragraph at lines 233--235
+[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][
+][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
+[][][][][][][][][][]  
+ []
+
+
+Underfull \vbox (badness 10000) has occurred while \output is active []
+
+ [43]
+Overfull \hbox (58.75392pt too wide) in paragraph at lines 325--326
+[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][
+][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]  
+ []
+
+) (Z:\scc300\src\cachingpolicy\emergenetic.dn [44]
+Overfull \hbox (466.77783pt too wide) in paragraph at lines 148--149
+[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][
+][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
+[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][
+][][][][][][][]  
+ []
+
+) (Z:\scc300\src\cachingpolicy\project\cachingpolicy\setup.sh)
+(Z:\scc300\src\cachingpolicy\project\cachingpolicy\config.conf [45])
+(Z:\scc300\dat\cache\difffile-large\17\chromosomes.txt) [46]
+(Z:\scc300\dat\runTests.sh) [47] (Z:\scc300\report\final-report.aux)
+
+LaTeX Font Warning: Size substitutions with differences
+(Font)              up to 1.98875pt have occurred.
+
+ ) 
+Here is how much of TeX's memory you used:
+ 18404 strings out of 493921
+ 369080 string characters out of 3146480
+ 519461 words of memory out of 3000000
+ 21258 multiletter control sequences out of 15000+200000
+ 58638 words of font info for 147 fonts, out of 3000000 for 9000
+ 844 hyphenation exceptions out of 8191
+ 55i,18n,67p,1330b,1578s stack positions out of 5000i,500n,10000p,200000b,50000s
+{C:/Program Files (x86)/MiKTeX/fonts/enc/dvips/fontname/8r.enc}<C:/Program Fi
+les (x86)/MiKTeX/fonts/type1/public/amsfonts/cm/cmex10.pfb><C:/Program Files (x
+86)/MiKTeX/fonts/type1/public/amsfonts/cm/cmmi12.pfb><C:/Program Files (x86)/Mi
+KTeX/fonts/type1/public/amsfonts/cm/cmmi8.pfb><C:/Program Files (x86)/MiKTeX/fo
+nts/type1/public/amsfonts/cm/cmr12.pfb><C:/Program Files (x86)/MiKTeX/fonts/typ
+e1/public/amsfonts/cm/cmr8.pfb><C:/Program Files (x86)/MiKTeX/fonts/type1/publi
+c/amsfonts/cm/cmsy10.pfb><C:/Program Files (x86)/MiKTeX/fonts/type1/public/amsf
+onts/cm/cmsy8.pfb><C:/Program Files (x86)/MiKTeX/fonts/type1/public/amsfonts/cm
+/cmsy9.pfb><C:/Program Files (x86)/MiKTeX/fonts/type1/public/amsfonts/symbols/m
+sam10.pfb><C:/Program Files (x86)/MiKTeX/fonts/type1/public/amsfonts/symbols/ms
+bm10.pfb><C:/Program Files (x86)/MiKTeX/fonts/type1/urw/courier/ucrb8a.pfb><C:/
+Program Files (x86)/MiKTeX/fonts/type1/urw/courier/ucrr8a.pfb><C:/Program Files
+ (x86)/MiKTeX/fonts/type1/urw/courier/ucrro8a.pfb><C:/Program Files (x86)/MiKTe
+X/fonts/type1/urw/helvetic/uhvb8a.pfb><C:/Program Files (x86)/MiKTeX/fonts/type
+1/urw/helvetic/uhvr8a.pfb><C:/Program Files (x86)/MiKTeX/fonts/type1/urw/helvet
+ic/uhvro8a.pfb><C:/Program Files (x86)/MiKTeX/fonts/type1/urw/palatino/uplb8a.p
+fb><C:/Program Files (x86)/MiKTeX/fonts/type1/urw/palatino/uplr8a.pfb><C:/Progr
+am Files (x86)/MiKTeX/fonts/type1/urw/palatino/uplri8a.pfb><C:/Program Files (x
+86)/MiKTeX/fonts/type1/urw/zapfding/uzdr.pfb>
+Output written on final-report.pdf (47 pages, 383434 bytes).
+PDF statistics:
+ 242 PDF objects out of 1000 (max. 8388607)
+ 0 named destinations out of 1000 (max. 500000)
+ 33 words of extra memory for PDF output out of 10000 (max. 10000000)
+
diff --git a/report/final-report.pdf b/report/final-report.pdf
new file mode 100644
index 0000000..1cdfe5f
Binary files /dev/null and b/report/final-report.pdf differ
diff --git a/report/final-report.synctex.gz b/report/final-report.synctex.gz
new file mode 100644
index 0000000..64c0512
Binary files /dev/null and b/report/final-report.synctex.gz differ
diff --git a/report/final-report.tex b/report/final-report.tex
new file mode 100644
index 0000000..eb909ad
--- /dev/null
+++ b/report/final-report.tex
@@ -0,0 +1,753 @@
+\documentclass[compsoc,12pt,a4paper]{IEEEtran}
+\usepackage{blindtext}
+\usepackage{color}
+\usepackage[margin=2cm]{geometry}
+\usepackage{graphicx}
+\usepackage{listings}
+\usepackage{tikz}
+\usetikzlibrary{shapes,arrows}
+\usepackage{wrapfig}
+
+\definecolor{dkgreen}{rgb}{0,0.6,0}
+\definecolor{gray}{rgb}{0.5,0.5,0.5}
+\definecolor{mauve}{rgb}{0.58,0,0.82}
+
+\lstset{ 	frame=none,
+				aboveskip=3mm,
+				belowskip=3mm,
+			  	showstringspaces=false,
+			 	columns=flexible,
+			 	basicstyle={\small\ttfamily},
+				numbers=none,
+			  	numberstyle=\tiny\color{gray},
+			  	keywordstyle=\color{blue},
+			  	commentstyle=\color{dkgreen},
+			  	stringstyle=\color{mauve},
+			  	breaklines=true,
+			 	breakatwhitespace=true,   
+			  	tabsize=3, 
+			  	escapeinside={(**}{*)}	}
+
+\usepackage{cite}
+\graphicspath{{./img/}}
+\DeclareGraphicsExtensions{.PNG}
+\usepackage[cmex10]{amsmath}
+\interdisplaylinepenalty=2500
+\usepackage{algorithm}
+\usepackage{algorithmic}
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage{wrapfig}
+
+% Define block styles
+\tikzstyle{decision} = [diamond, draw, fill=blue!20, text width=4.5em, text badly centered, node distance=3cm, inner sep=0pt]
+\tikzstyle{block} = [rectangle, draw, fill=blue!20, text width=5em, text centered, rounded corners, minimum height=4em]
+\tikzstyle{line} = [draw, -latex']
+\tikzstyle{cloud} = [draw, ellipse,fill=red!20, node distance=3cm, minimum height=2em]
+
+% *** SUBFIGURE PACKAGES ***
+%\usepackage[tight,footnotesize]{subfigure}
+% subfigure.sty was written by Steven Douglas Cochran. This package makes it
+% easy to put subfigures in your figures. e.g., "Figure 1a and 1b". For IEEE
+% work, it is a good idea to load it with the tight package option to reduce
+% the amount of white space around the subfigures. subfigure.sty is already
+% installed on most LaTeX systems. The latest version and documentation can
+% be obtained at:
+% http://www.ctan.org/tex-archive/obsolete/macros/latex/contrib/subfigure/
+% subfigure.sty has been superceeded by subfig.sty.
+
+
+%\usepackage[caption=false]{caption}
+%\usepackage[font=footnotesize]{subfig}
+% subfig.sty, also written by Steven Douglas Cochran, is the modern
+% replacement for subfigure.sty. However, subfig.sty requires and
+% automatically loads Axel Sommerfeldt's caption.sty which will override
+% IEEEtran.cls handling of captions and this will result in nonIEEE style
+% figure/table captions. To prevent this problem, be sure and preload
+% caption.sty with its "caption=false" package option. This is will preserve
+% IEEEtran.cls handing of captions. Version 1.3 (2005/06/28) and later 
+% (recommended due to many improvements over 1.2) of subfig.sty supports
+% the caption=false option directly:
+%\usepackage[caption=false,font=footnotesize]{subfig}
+%
+% The latest version and documentation can be obtained at:
+% http://www.ctan.org/tex-archive/macros/latex/contrib/subfig/
+% The latest version and documentation of caption.sty can be obtained at:
+% http://www.ctan.org/tex-archive/macros/latex/contrib/caption/
+
+
+\hyphenation{op-tical net-works semi-conduc-tor}
+
+\begin{document}
+	
+	\title{\vspace{8.0cm}---EmerGen(e)tic---\\Exploring the use\\of genetic algorithms\\in emergent distributed\\systems}
+	
+	\author{\vspace{2.0cm}Ben Goldsworthy, 33576556\\Computer Science BSc}
+	
+	\maketitle
+	
+	\onecolumn
+
+	\section*{Declaration}
+	
+		I certify that the material contained in this dissertation is my own work and does not contain unreferenced or unacknowledged material. I also warrant that the above statement applies to the implementation of the project and all associated documentation. Regarding the electronically submitted version of this submitted work, I consent to this being stored electronically and copied for assessment purposes, including the School's use of plagiarism detection systems in order to check the integrity of assessed work.\\
+		I agree to my dissertation being placed in the public domain, with my name explicitly included as the author of the work.\\
+		All working documents and results can be found at \lstinline|www.lancaster.ac.uk/ug/goldswor/scc300/|.\\\\
+		Date:\\
+		Signed:
+		
+
+	\newpage
+
+	\begin{abstract}
+		Adaptive and emergent systems exist to attempt to answer the deficiencies inherent to distributed systems, and the necessarily finite ability of any programmer to predict all possible eventualities in which his software may one day find itself. This paper argues that these systems fail to go far enough, and then proposes a further development---genetic systems---which utilises genetic programming to extend the versatility of a given system massively, if not infinitely. This paper then proceeds to detail the EmerGen(e)tic framework for rapidly testing genetic algorithm modules within emergent systems, as well as an example module pertaining to the cache updating behaviour of a web server. This paper concludes by proposing further avenues of potentially-fruitful research based upon these programs and its findings.
+	\end{abstract}
+	
+	\newpage
+	
+	\section{Introduction}
+	\label{sec:introduction}
+	
+		Coulouris \textit{et al.} (2012) define a \textit{distributed system} as `[...]one in which components located at networked computers communicate and coordinate their actions only by passing messages.'\cite{distsys} By the very nature of distributed computing, any system will---as a whole---experience a range of fluctuating conditions and environments that may affect its performance. Although a well-designed, reliable distributed system will be developed to be `as fault tolerant as possible'\cite{reliable} and with as many of these potential operating environments as possible in mind, the totality of all possible conditions for all possible futures in which the system remains in use is impossible for the original developer(s) to have been entirely predicted and accounted for. This inhibits the universality of current distributed systems, as well as incurring future maintenance and development costs when they need to be adapted for future circumstances.\\
+		\textit{Adaptive systems} are a subset of distributed systems in which the system is given a number of submodules that define different behaviour, and the system is programmed with policies for determining which submodule to use for a given task. An example may be a file server that has a compression module activate when serving a file over a given filesize. Whilst this adaptive behaviour does increase the system's operational range, it still requires manual programming of policies and thus suffers from the same issues as the general distributed systems.\\
+		\textit{Emergent systems} are a proposed solution to these limitations. Emergent systems are a subset of adaptive systems in which the system itself determines the best configuration to deal with a given situation by trying multiple configurations and assessing their performance against a given metric. This, coupled with some form of storage for recording previously-discovered optimum solutions that can be consulted heuristically for improved performance, provides a more adaptive final system whilst simultaneously reducing development overheads.\\
+		Filho \& Porter (2016) best outline the problem in response to which emergent systems have been developed, stating that (emphasis theirs) `[human-centric] approaches [to self-organising software] rely on prediction of how a system will respond to environments (which may turn out to be false) and result in \textit{inflexibility} [whilst a] \textit{machine-centric} approach [...] moves the burden of complexity into software itself, avoids the need for prediction of behaviours, and supports total flexibility [...]'.\cite{machinecentric}\\
+		However, these emergent systems are not too without their limitations. Whilst they do possess far more flexibility with regards to arranging themselves into new and unpredicted configurations than does a simpler adaptive system, they are yet constrained by the finite pool of components they have access to, which are still developed by human hand.\\
+		\begin{algorithm}
+			\caption{Basic genetic algorithm}
+			\label{alg1}
+			\begin{algorithmic}
+				\REQUIRE initial population
+				\REQUIRE num. of generations
+				\REQUIRE num. of candidates per generation
+				\FORALL{generations}
+					\FORALL{chromosomes in generation}
+						\STATE{run test on chromosome}
+						\RETURN{fitness score of chromosome}
+					\ENDFOR
+					\FOR{strongest chromosome(s) in generation}
+						\STATE{copy over to next generation}
+					\ENDFOR
+					\FOR{remaining chromosomes in generation}
+						\IF{small probability = true}
+							\STATE{apply mutation/crossover operation}
+						\ENDIF
+						\STATE{copy over to next generation}
+					\ENDFOR
+				\ENDFOR
+			\end{algorithmic}
+		\end{algorithm}
+		\textit{Genetic algorithms} rely on metaphors from evolutionary biology such as random mutation and natural selection in order to develop---over the course of multiple iterations and utilising a finite set of operations---improved software, with each generation ideally moving closer towards an optimal solution as specified via the result of a given fitness function $f\left(\right)$. They have been used to produce everything from spaceship antennae\cite{antenna} to software bug checkers.\cite{genprog} In a previous work,\cite{ants} this author applied genetic algorithms to the development of simulated ants. Algorithm \ref{alg1} shows the algorithm by which genetic programming is performed.\\
+		On the one hand, we have systems that need to be freed from human development as much as possible in order to be generalisable to the widest range of possible operating environments. On the other, we have a programming approach in which the human developer sets up a number of variables before reclining whilst the computer handles the rest of the time-consuming programming work---the two fields would appear to be ready allies. If genetic programming could be effectively applied to the generation of components for an emergent software system, it would allow the creation of an infinite pool of potential components and allow the system to theoretically surmount any given situation, given enough time.\\
+		Thus, the research questions that this project aims to satisfy are:
+		\begin{itemize}
+			\item can genetic algorithms be productively used to produce optimum components for an emergent system? and
+			\item assuming so, what are the optimal conditions for doing so (i.e. mutation probabilities, generation sizes, etc.)?
+		\end{itemize}
+		From these research questions come the aims for this project; they are:
+		\begin{itemize}
+			\item to produce a framework for enabling rapid development of genetic improvement tests,
+			\item to test a small, simple program to hopefully demonstrate improvement through application of these techniques and
+			\item to repeat the tests multiple times with a variety of conditions and see what, if any, trends emerge.
+		\end{itemize}
+		This report is divided into eight sections:
+		\begin{enumerate}
+			\item `Introduction', in which the broad goal of the project in question is outlined,
+			\item `Background', in which the history of the field in question is outlined in more detail,
+			\item `Design', in which the design of the present solution is outlined in a non-technical manner, from first principles,
+			\item two `Implementation' sections, in which the technical implementation of both the EmerGen(e)tic genetic testing framework and the specific \lstinline|cachingpolicy| module is detailed,
+			\item `The System in Operation', in which usage---and normal output---of the systems above are described,
+			\item `Testing \& Evaluation', in which the results of testing on the systems above are investigated and the project as a whole evaluated, with its successes and failures candidly discussed and
+			\item `Conclusion', in which the research questions above are revisited and avenues for future research signposted.
+		\end{enumerate}
+
+	\newpage
+	
+	\section{Background}
+	\label{sec:background}
+	
+		\subsection{Assumptions}
+		
+			This project operates on a foundation of two assumptions, neither of which---though they may both appear to be---are axiomatic.\\
+			
+			\noindent \textbf{Assumption \#1: Programming is hard}\\
+			
+			\noindent IBM found that the cost of fixing a bug can range from a base cost (for one discovered during the requirements elicitation phase of software design) to 100$\times$ that (for one identified in the maintenance phase).\cite{bugcost} With the lengths of written software steadily increasing---1993's Windows NT 3.1 had 4.5m lines of code to 2003's Windows Server 2003's 50m---and an average of `about 15--50 errors per 1000 lines of delivered code',\cite{1000} these problems are being exacerbated.\footnote{For further exploration by myself of the resultant security risks of this, amongst other factors, see \cite{cni}.} As such we desire to systems that will perform as many programming responsibilities on our behalf as possible, as well as as much of the checking, testing and validation work as we can get away with---repetitive, methodical tasks such as testing especially represent the perfect area for a computer, but not man. We also desire systems that can be constructed out of smaller, simpler parts that can be more rigorously tested prior to deployment.\footnote{cf. the `Unix philosophy', best detailed in \cite{unix}} It is these goals that has led to the development of distributed, adaptive and emergent systems, as well as genetic programming.\\
+				
+			\noindent \textbf{Assumption \#2: Circumstances change}\\
+			
+			\noindent It would be hubris \textit{par excellence} to assume that humanity has learnt all that there is to learn and can be surprised no longer. Bronze age man discovered ironwork, assumptions of classical physics were rent asunder by the discovery of quantum physics and the discovery of non-Euclidean geometry is said to have `marked the end of an entire line of human thought, one that had dominated intellectual efforts in the West for centuries.'\cite{geometry} No one programmer---nor a team of programmers---can hope to have perfect, 20/20 foresight encompassing all of the environmental possibilities in which their system may find itself deployed in the future. Even if they could, theoretically, handle all possible situations as are known to them now, there is every possibility of a non-Euclidean geometry-esque upending of the conventional wisdom occurring at an unspecified point in the future, entirely incomprehensible from within the bounds of their Euclidean worldview---they would be akin to the denizens of Abbott's \textit{Flatland}, trying to conceive of the third dimension.
+			
+		\subsection{Distributed and Adaptive Systems}
+		
+			\textit{Distributed systems}---amusingly described by Lamport (1987) as `[a system] in which the failure of a computer you didn't even know existed can render your own computer unusable'\cite{email}---have their origins in the early days of computing and the concept of multiprogramming. Carr, Crocker \& Cerf (1970) outlined ARPANET, `one of the most ambitious computer networks attempted to date'.\cite{rfc} As one of the first networks, ARPANET serves an example of one of the first instances of distributed computing and a predecessor to the modern-day Internet. Coulouris \textit{et al.}'s  definition of a distributed system as `[...]one in which components located at networked computers communicate and coordinate their actions only by passing messages'\cite{distsys} may, however, begin to make the drawbacks of such a system apparent. As these computers are in different geographic locations, their needs and experiences may differ---a program written in California may work fine on the fast, reliable internet connections that are all its developer may have ever experienced, but less so for the instance of it running in rural India.\\
+			One solution to these issues is \textit{adaptive systems}, in which a distributed system is given a number of submodules containing different approaches to its tasks. The developer will then program in various policies for which modules to use in which conditions. Examples of this could include a live online video player that resorts to a different quality of transmission when being broadcast to a client with a suboptimal network connection. Again, the Internet is an excellent example of an adaptive system: with various protocols on offer, a developer can choose the one that best suits a given need. If error detection and correction is important, TCP is the tool for the job; if it is not, then UDP provides a faster transmission with less overhead.\\
+			However, these adaptive systems fail to resolve the initial issue of the developer having to predict the myriad situations his program may find itself running in in the future. By still requiring the developer's input in specifying the various module combination strategies and policies, all these systems achieve is to allow the developer to write more generalised, less specific (sub)programs. This may be beneficial for rapid reuse elsewhere, but is otherwise not the solution we seek.
+		 
+		\subsection{Emergent Systems}
+		
+			One such proposed solution, however, is the \textit{emergent system}, or an adaptive system in which the program itself (or a framework on top of it) designs its own policies based on trial-and-error and recording performance rates of different combinations of submodules, the name coming from the possibility of such a system discovering optimal behaviour unpredicted by its human creators.\\
+			Dana\footnote{Dana documentation and downloads can be found at \lstinline|www.projectdana.com|} is a component-based language designed specifically for emergent system programming by Porter (2014), described by the author as `an imperative, procedural, interpreted language, [that] is multi-threaded, and features only interface, record and primitive types'\cite{dana}---it is also `syntactically similar to contemporary languages like Java'\cite{dana}.\\
+			Filho \& Porter (2016a) describe a web server written in Dana.\footnote{For an explanation of the function of Filho \& Porter's web server, as well as concepts such as `caching' and `compression', see \S \ref{sec:design}} The web server receives requests for files---a mixture of file types and sizes---from clients and serves them up. The server can construct behaviour out of a number of components that enable different policies for cache updating, file compression, etc. The authors test the server in every possible configuration and against different styles of workload, measuring the request response time per configuration.\\
+			The authors showed that different configurations gave markedly different results---for example, for a `Workload 1 [consisting] of one client repeatedly requesting only one text-only HTML file, [a particular architecture] performs best because, in this configuration, the web servers always compress the requested files, and once the file is returned to the load balancer, it is stored in a small content  cache  at  the  load  balancer.'\cite{machinecentric} Meanwhile, a cacheless architecture performed better at a workload consisting of `one client requesting a different text-only HTML file for every request'\cite{machinecentric} as caching would provide no benefit for a constantly-changing series of requests and would only add pointless overhead.\\
+			In a further paper, Filho \& Porter (2016b), the authors go onto elucidate the limitations of a simple adaptive system, arguing that `[the] requirement [for human specification of control strategies] is fundamentally opposed to  the  core  ideas  behind  autonomic  computing,  which  are borne of the increasing difficulty for humans to understand modern software systems in dynamic environments.'\cite{losingcontrol} Developing further their web server platform, they implement a perception and learning system so that the web server can analyse the performance of varied configurations and determine an optimum arrangement for a given task. Finally, in Filho \textit{et al.} (2016), this is consolidated into the single framework RE$^{\text{X}}$, which `produce[s] systems that are responsive to the actual conditions that they encounter at runtime, and the way they perceive their behaviour in these conditions.'\cite{rex}\\
+		Other frameworks within the same field of emergent systems exist, such as Elkhodary, Esfahani \& Malek (2010)'s FUSION,\cite{fusion} but I assert the following with this paper: that the very idea of emergent systems as a whole fails to go far enough towards solving the issues it was formulated in response to.
+		
+		\subsection{`Genetic Systems'}
+		
+			Floyd (1979) said that the following words were written on the wall of a Stanford University graduate student office: `I would rather write programs to help me write programs than write programs.'\cite{floyd} This is a succinct description of the goals of genetic programming, in which representations (usually tree representations) of computer programs are modified using a set of mutation and crossover operators and a set of varying probabilities for each to occur. These changes take place across multiple generations and should, hopefully, trend towards better-performing programs. The applications are vast: Le Goues \textit{et al.} (2012) applied them to automated software bug fixers;\cite{genprog} Hansen \textit{et al.} (2007) to counter-cyberterrorism;\cite{security} Hornby \textit{et al.} (2015) to the shape of spacecraft antennae;\cite{antenna} and the author of this paper to the production of simulated ants.\cite{ants}\\
+			Indeed, the wall of Stanford's student office neatly encapsulates the thinking behind the proposal of this paper as to the viability and desirability of applying genetic programming techniques within the emergent system space--what this author will propose to be described as `genetic systems'. If an emergent system can already assemble configurations of provided submodules, test them and rank them, and the goal is to eliminate the developer from the software development equation as much as possible, then what is next? Why not have the system assemble the submodules themselves? This would increase the pool of potential submodules available to the program to be theoretically infinite, and the same benefits of this emergent behaviour would apply here too. It is this hypothesis that is to be tested within this paper.
+	
+	\newpage
+	
+	\section{Design}
+	\label{sec:design}
+	
+		Within this section the design of the EmerGen(e)tic (from `emergent' and `genetic') system is outlined. Following that, the web server and caching system used within the \lstinline|cachingpolicy| module are outlined, from first principles, for the non-technical user's understanding. For a technical overview, see \S \ref{sec:cachingpolicyimpl}.
+			
+		\subsection{EmerGen(e)tic}
+		
+			The primary goal of this project was to produce a framework for quickly and easily allowing future projects to test the effects of genetic algorithms on varying elements of varying systems. To do this, a master Dana program was created which runs through each generation, calling a separate file (hereafter referred to as a \textit{module}) to handle all of the the evolutionary logic---the mutations, crossovers, selections, etc. This is so that future developers can easily plug `n' play with their own genetic modification modules in the future. The master program will then run through all the candidates from each generation to test their responses to differing stimuli. The testing functionality is contained within a single method, and so should be the only part of the EmerGen(e)tic code that a future developer needs to modify to implement their own project.\\
+			To assist with generalisability, as many settings as possible (e.g. mutation probability, file(s) to test with, number of generations) were left to be externally set via either command-line arguments or config. files.\\
+			The below flowchart shows the intended operation of the system:\\   
+			\begin{center}
+			\begin{tikzpicture}[node distance = 4.5cm, auto]
+			    % Place nodes
+			    \node [block] (init) {EmerGen(e)tic};
+			    \node [block, left of=init] (results) {Results};
+			    \node [block, below of=results] (script) {Mutation module};
+			    \node [block, below of=script] (generation) {Generation $x$};
+			    % Draw edges
+			    \path [line] (init) -- (script) node[midway,left,align=center] {1. For each gen.\\call module};
+			    \path [line] (script) -- (generation) node[midway,left,align=center] {2. Create next\\gen.'s pop.};
+    			 \path [line] (init) |- (generation) node[midway,right,align=center] {3. Test generation};
+    			 \path [line] (init) -- (results) node[midway,above,align=center] {4. Output\\results};
+			\end{tikzpicture}
+			\end{center}
+			
+		\subsection{The Web Server}
+			
+			\subsubsection{How a web server works}
+			
+				A \textit{web server} is a type of computer. It can receive requests from other computers (called `clients') for the files that are located within it via a number of methods, usually across an Internet connection, such as HTTP. Once it has received a request, which will contain the name of the file requested, it searches its file storage for a match. If it finds it, it sends the data of the file back to the client. If it does not, it should return a message that the client knows to interpret as an error message. Below is a flowchart of how a web server works:\\
+				\begin{center}
+				\begin{tikzpicture}[node distance = 6cm, auto]
+				    % Place nodes
+				    \node [block] (client) {Client};
+				    \node [block, below of=client] (webserver) {Web Server};
+				    \node [block, right of=webserver] (file) {File Store};
+				    % Draw edges
+				    \path [line] (client) -- (webserver) node[midway,left,align=center] {1. Client requests\\file};
+				    \path [line] (webserver) -- (file) node[midway,above,align=center] {2. Server retrieves\\file from\\file store};
+	    			 \path [line] (file) -- (webserver);
+	    			 \path [line] (webserver) -- (client) node[midway,right,align=center] {3. Server returns\\file\\(or error)};
+				\end{tikzpicture}
+				\end{center}
+			
+			\subsubsection{Added extras}
+		
+				This is the most basic form of web server---for every request, it trawls through its files for a match and then returns that to the client. However, there are numerous extra functions that can be added to improve performance, and which can be combined to best suit various situations. For example, files can be compressed through various schemes in order to reduce their filesize before sending, and then decompressed at the client's end, which shortens the amount of time taken to transmit the (now-smaller) file.\\
+				However, the one most relevant to this project is \textit{caching}. In caching, a cache is kept---this is a section of storage that is faster to retrieve data from than the regular file store, but which does not have the size to hold the full file store. When a file is returned for a client's request, it is also added to the cache. This means that if a client then requests the same file again, it will be found within the cache and returned faster than if the entire file store had to be searched.\\
+				Obviously, the cache will at some point fill up. At this point, various policies for updating a full cache can be implemented. The simplest is to simply start again at the beginning and overwrite the first item. More complex ones can bring in variables like which file was requested least recently, or has been requested the fewest times, in order to try and improve speed. Again, different policies suit different situations, and there is no `magic bullet'.
+				
+			\subsubsection{A tale of two web servers}
+			
+				The present project is based off of Filho \& Porter's Dana web server code. Their project includes a client program, which is given a list of files grouped by various criteria (e.g. all large files, all image files, mixtures of both, etc.). It then sends the server program HTTP requests for each file in the list until it reaches the end. In this particular version of the software Filho \& Porter's PAL system is implemented, meaning every possible configuration found is tried---this means that each file is tested with every combination of the provided caching and compression methods, and the response time of the server (in ms) recorded. This response time is the metric by which the PAL system ranks various configurations.\\
+				The goal of Filho \& Porter's project was to demonstrate improvements in file handling when using different combinations of policies for different types of request patterns. However, for the present project, the system is too complex to control all of the independent variable required for the tests to be run. As such, the scope of inquiry had to be limited to caching policy only. As such, much of Filho \textit{et al.}'s server project code was removed. This left only the caching functionality and some remnants of the web server code.
+		
+		\subsection{Caching}
+		\label{sec:caching}
+		
+			Cache behaviour is located within the \lstinline|/cache/CacheHandler*.dn| family of components. Filho \& Porter's server code contains six \lstinline|CacheHandler*| variants, each with different policies for determining which item in a full cache---represented by a fixed-size array---to replace with a newly-requested file, as well as a simple cache system in which the cache is only one item long. The other methods are:
+			\begin{itemize}
+				\item serial replacement, where each item in turn is replaced, returning to the first item upon reaching the end of the array,
+				\item most- and least-frequently used,
+				\item most- and least-recently used. 
+			\end{itemize}
+			For example, \lstinline|CacheHandlerMFU.dn| contains the policy for replacing the most-frequently used cache item.\\
+			Within each of these variant cache handling policy files there is necessarily a lot of duplicated code. Common to all variants are the method signatures (but not bodies) for:
+			\begin{itemize}
+				\item \lstinline|updateCache()|, which updates a full cache using the variant's specified policy,
+				\item \lstinline|clearCache()|, which clears the cache completely, and
+				\item \lstinline|getCachedResponse()|, which returns either the item that was received from the cache or \lstinline|null| to the caller.
+			\end{itemize}
+			Cache initialisation is handled as a conditional within \lstinline|updateCache()| (i.e. if there is no cache present, it creates one and places the current item in cache index 0).\\
+			There are also a series of functions that are only present in individual \lstinline|CacheHandler| files, such as \lstinline|mostRecentlyUsed()| in \lstinline|CacheHandlerMRU.dn|. This does what is says on the tin, returning the most recently-used item from the cache to be overwritten. Another example is \lstinline|random()| (within \lstinline|CacheHandlerR.dn|), which unsurprisingly returns a random item from the cache.\\
+			For the genetic algorithm to work it needs a base file. The base file requires all of the common functionality present and marked as out-of-bounds for the genetic algorithm. Included in these out-of-bounds methods would be the full complement of methods such as \lstinline|mostRecentlyUsed()|, which could be called upon or not as decided by a given output program.
+		
+		\subsection{The `Cache Policy' Genetic Algorithm}
+		
+			The basic workings of a genetic algorithm were covered in \S \ref{sec:introduction}, but here the specifics of the algorithm as applied to this project shall be outlined.\\
+			As this project is concerned only with modifying cache updating behaviour, and thus in how to produce an index value given differing formulae, the most important line is line 110 of \lstinline|CacheHandlerBase.dn|:
+			\begin{lstlisting}[language=Java]
+				index = 0
+			\end{lstlisting}
+			The formula on the right-hand side of that assignment is the scope for mutation. From that initial `\lstinline|0|' must sprout new formulae---these formulae are what is referred to in the remainder of this report as \textit{chromosomes}. A single \textit{generation} will consist of multiple \lstinline|CacheHandler*.dn| files (or \textit{candidates}), each of which will contain a single chromosome. Within each generation, therefore, shall exist multiple distinct chromosomes. Each of these sets of chromosomes is known as the generation's \textit{population}.\\
+			As mentioned before, the basic tools of a genetic algorithm are the operations of \textit{mutation} and \textit{crossover}, which shall be discussed below (along with a heuristic known as `elite selection'):\\
+			
+			\noindent\textbf{Mutation}\\
+			
+			\noindent In mutation, a section of chromosome $A$ is replaced with a new value. For example, from the example chromosome `\lstinline|0|', an operand mutation operation could change it to `\lstinline|4|'. For the mutation within the scope of this project, four types of mutation were implemented:
+				\begin{itemize}
+					\item binary operator mutation (e.g. `\lstinline|2+4|' into `\lstinline|2*4|'),
+					\item operand mutation,
+					\item unary operator mutation (e.g. `\lstinline|nthMostRecentlyUsed(2)|' into `\lstinline|nthMostFrequently- Used(2)|'), and
+					\item subtree creation (e.g. `\lstinline|2+2|' into `\lstinline|2+(4*2)|').
+				\end{itemize}
+				The first three simply randomly change elements of the chromosomes in the hopes of finding particularly efficacious variants. The fourth, however, serves the vital role of allowing the chromosomes---which all start as `\lstinline|0|'---to increase in complexity.\\
+				
+			\noindent\textbf{Crossover}\\
+			
+			\noindent In crossover, two chromosomes $A$ and $B$ are selected. A random section of $A$ ($A'$) is then taken and inserted at a random point of $B$ ($B'$) to produce a new chromosome $C$. For example, take
+				\begin{gather*}
+					A = \text{ \lstinline|2+(4+3)|}\\
+					B = \text{ \lstinline|4*3|}
+				\end{gather*}
+				and an $A'$ of `\lstinline|+(4+3)|' and a $B'$ between the `\lstinline|4|' and the `\lstinline|*|'---we produce
+				\begin{gather*}
+					C = \text{ \lstinline|4+(4+3)*3|}
+				\end{gather*}
+				Variants of crossover also exist, such as multi-point crossover (where multiple $A'$s are copied over to multiple $B'$s). However, for this project, only single-point crossover was implemented due to time constraints.\\
+				
+			\noindent\textbf{Elite Selection}\\
+			
+			\noindent There are a number of time-saving tactics (or \textit{heuristics}) that can be used to speed up the performance of a genetic algorithm. One such heuristic, implemented within this project, is \textit{elite selection}. This takes an arbitrary percentage of top-performing chromosomes for any generation (in this instance, the top 10 \%) and copies them across to the next generation unchanged. This ensures that optimal solutions are not simply discarded upon the next generation.
+		
+	\newpage
+	
+	\section{Implementation: EmerGen(e)tic}
+	\label{sec:implementation}
+	
+		This section contains a more technically-detailed overview of the implementation of the EmerGen(e)tic program.
+		
+		\subsection{Folder Structure}
+		
+			The base folder structure for EmerGen(e)tic is as follows:
+			\begin{itemize}
+				\item \lstinline|/archives/|, where archives of test run data go when after completion of a script's run,
+				\item \lstinline|/project/|, which contains the mutation project modules,
+				\item \lstinline|/resources/|, which contains Dana overhead,
+				\item \lstinline|/results/|, which contains per-generation and per-script results files and
+				\item \lstinline|/scripts/|, which contains \lstinline|.script| files for running through multiple tests, grouped by some criterion/criteria.
+			\end{itemize}
+			
+		\subsection{\lstinline|emergenetic.dn|}
+		
+			This Dana file contains the framework for running and testing genetic algorithm projects.\footnote{See Appendix \ref{appendix:emergen}} Passed to it are a number of command-line arguments, including the module to load and the number of generations to test.
+			
+			\subsubsection{\lstinline|App:main()|}
+			
+				The program is entered through the \lstinline|App:main()| method, whereupon the passed arguments are validated---if any are invalid, detailed error messages are output and the program terminates. The method runs the setup file \lstinline|setup.sh| from within the passes module directory (and passes the result to a variable of type \lstinline|RunStatus|, which can be helpful for debugging), and then iterates through each generation. For each generation, it runs the given module's \lstinline|mutator.py| program, followed by the \lstinline|runGeneration()| method.\\
+				Upon successfully finishing the iteration of each generation, the program exits with a code of `0'---in the event of invalid arguments, it exits with a code of `1'.
+	
+			\subsubsection{\lstinline|runGeneration()|}
+			
+				The \lstinline|runGeneration()| calls the \lstinline|runCandidate()| method for each candidate within the given generation. Once this is done, it appends a newline to the \lstinline|results.csv| file within the \lstinline|results| directory.
+				
+			\subsubsection{\lstinline|runCandidate()|}
+			
+				This is the point at which a future developer will implement their own code for running and testing candidates for their own projects. In the base release of \lstinline|emergenetic.dn|, it is left blank.
+				
+			\subsubsection{\lstinline|printResults()|}
+			
+				This method prints the results of each test run to output. It then also appends the results of the run to the per-generation results file \lstinline|results|$x$\lstinline|.txt|, and to the per-script results file \lstinline|results.csv| within the \lstinline|results| directory.
+	
+	\newpage
+	
+	\section{Implementation: \lstinline|cachingpolicy|}
+	\label{sec:cachingpolicyimpl}
+		
+		In this section, the technical implementation of the \lstinline|cachingpolicy| module used for this project is detailed.
+		
+		\subsection{Folder Structure}
+			
+			In addition to the base folder structure of EmerGen(e)tic, the following directories were added.
+			\begin{itemize}
+				\item \lstinline|/cache/|, where the generations of various \lstinline|CacheHandler*.dn| files are kept, each within a directory numbered with their generation number and in files of the format \lstinline|CacheHandler|$x$\lstinline|_|$y$\lstinline|.dn|, where $x$ is the number of the generation and $y$ is the number of the candidate,
+				\item \lstinline|/cachebackup/|, which contains a fresh copy of \lstinline|CacheHandlerBase.dn| for quickly clearing the \lstinline|/cache/| directory after a full test run,
+				\item \lstinline|/htdocs/|, which contains all the files to request from the web server,
+				\item \lstinline|/project/cachingpolicy|, which contains the files for the \lstinline|cachingpolicy| module and
+				\item \lstinline|/resources/cache|, which contains the Dana specifications for the caching components.
+			\end{itemize}
+			
+		\subsection{Genetic Algorithm search space}
+		
+			Before a genetic algorithm can be implemented, the search space must be defined:
+			\begin{gather*}
+				 \text{Let }c\text{ represent the cache length} \\
+				 \text{Let }l\text{ represent an AST leaf values} \\
+				 \text{Let }n\text{ represent an AST node values} \\\\
+				 l \in \mathbb{N} \\
+				 n \in \left\{\times, +, -, \div, MostFrequent\left(\right), MostRecent\left(\right), Rand\left(\right) \right\} \\\\
+				 \text{Let }a\left(n\right)\text{ be a function that returns the arity of function }n \\
+				 \text{Let }r\text{ represent the result of }n\left(\right)\text{, }n\left(l\right)\text{ or }n\left(l_1, \dots, l_{a\left(n\right)}\right) \\
+				 \text{Let }i\text{ represent the cache index value to replace} \\\\
+				 r\in \mathbb{N} \\
+				 i \in \left\{x \in \mathbb{N} : 0 \leq i \leq c-1\right\} \\
+				 \therefore i = r \bmod{\left(c-1\right)}
+			\end{gather*}\\
+			In real terms then, the the set of actual Dana operators and methods $n_{Dana}$ used was
+			\[ n_{Dana} \in \left\{\text{\lstinline|*|}, \text{\lstinline|+|}, \text{\lstinline|-|}, \text{\lstinline|/|}, \text{\lstinline|nthMostFrequentlyUsed()|}, \text{\lstinline|nthMostRecentlyUsed()|}, \text{\lstinline|random()|}\right\} \]
+			and the resolve flag $res$, which was passed through to \lstinline|nthMostFrequentlyUsed()| and \lstinline|nthMostRecentlyUsed()| as a constant in each individual program, was of the value
+			\[res \in \left\{\text{\lstinline|n|}, \text{\lstinline|o|}, \text{\lstinline|r|}\right\}\]
+			
+		\subsection{\lstinline|CacheHandlerBase.dn|}
+			
+			From the various \lstinline|CacheHandler*.dn| files within Filho \& Porter's \lstinline|/cache/| were distilled the common elements of each (the methods covered in \S \ref{sec:caching}), collected into one file.\footnote{See Appendix \ref{appendix:base}} 
+
+			\subsubsection{\lstinline|CacheHandler:getGetCachedResponse()|}
+			
+				This method returns an item specified in a request from the cache if it exists there---otherwise, it returns \lstinline|null|.
+
+			\subsubsection{\lstinline|CacheHandler:updateCache()|}
+				
+				This method updates the cache if a requested item is not already in it. If the cache is full, this method contains the formula for determining the cache index to replace. Lines 70--71---demarcated with the comments \lstinline[language=Java]|// BEGIN| and \lstinline[language=Java]|// END|---indicate to the genetic algorithm its bounds of operation. Within these lines, the method for determining cache index $i$ is determined for each chromosome.
+			
+			\subsubsection{\lstinline|CacheHandler:clearCache()|}
+			
+				This method clears the cache completely.
+			
+			\subsubsection{\lstinline|nthMostFrequentlyUsed()|, \lstinline|nthMostRecentlyUsed()| \& \lstinline|random()|}
+			
+				These methods return the item in the cache that fits their criterion (or, in the case of \lstinline|random()|, a random item). Including all of the various most/least frequently/recently used methods would lead to an unnecessarily large file, so they were generalised into the methods \lstinline|nthMostFrequentlyUsed()| and \lstinline|nthMostRecentlyUsed()|, which each take their $n$ as an argument.
+				
+			\subsubsection{\lstinline|resolve()|}
+			
+				The \lstinline|resolve()| method takes a flag indicating how to resolve the situation of multiple returns from one of the aforementioned three methods (e.g. in the event that the least-frequently used file is not the only file in the cache with that number of hits). The flag can be set to return either the newest item, the oldest or a random choice.
+			
+		\subsection{\lstinline|emergenetic.dn|}
+		
+			Within the \lstinline|runCandidate()| method,\footnote{See Appendix \ref{appendix:runcand}} the \lstinline|CacheHandler| component within \lstinline|CacheHandler*.dn| is loaded using Dana's \lstinline|RecursiveLoader|, which ensures that all of its dependencies are also loaded. A timer is started and each file within the given script file is requested from the web server. When the script file is finished, the timer is stopped and the overall time taken (and that the value represented ms) is passed to \lstinline|printResults()|. As \lstinline|RecursiveLoader| lacks an \lstinline|unload()| method, each of the loaded components is then looped through and \lstinline|unload()| called on them in turn.
+		
+		\subsection{\lstinline|cachingpolicy/mutator.py|}
+		\label{sec:python}
+		
+			This Python file contains the genetic algorithm logic for the \lstinline|cachingpolicy| module.\footnote{See Appendix \ref{appendix:genetic}} It can be run as a standalone Python script or imported as a Python module into other projects.
+		
+			\subsubsection{\lstinline|getSubLists()|}
+			
+				This method recursively produces a \lstinline|List| of nested \lstinline|List|s representing every subtree present within a given chromosome (i.e. every bracketed expression).
+			
+			\subsubsection{\lstinline|crossover()|}
+			
+				This method performs single-point crossover between two chromosomes passed to it as arguments $A$ and $B$. It first calls \lstinline|getSubLists()| on $A$ in order to get a \lstinline|List| of all the possible subtrees of $A$. It then randomly chooses points within $B$ until it finds an operand token, at which point it replaces the operand with a randomly-chosen \lstinline|List| from $A$.
+			
+			\subsubsection{\lstinline|mutate()|}
+			
+				This method performs four distinct multiple-point mutations. If it is the first run it imports the individual mutation probabilities from \lstinline|config.conf|, and if it is the initial population it overrides the mutation probability to be 100 \%. It then recursively iterates over each token in the chromosome and has a chance to possibly apply one of the mutation operations. The recursive element comes in when it encounters a token of type \lstinline|List| (i.e. a bracketed expression), in which case it calls \lstinline|mutate()| upon the sublist.
+			
+			\subsubsection{\lstinline|parse()| \& \lstinline|compile()|}
+			
+				The former of these methods takes an expression as a string (e.g. `\lstinline|2+(4*2)|') and returns a \lstinline|List| representation (with nested \lstinline|List|s for bracketed expressions). The latter takes such a \lstinline|List| and returns the original string expression.
+				
+			\subsubsection{\lstinline|createInitialPop()|}
+			
+				If the python script is called with a generation argument of `0' it calls the \lstinline[language=python]|createInitialPop()| method first. This creates an initial population by copying over \lstinline|CacheHanderBase.dn| and applying \lstinline[language=python]|mutate()| to each candidate with a 100 \% mutation probability.
+			
+			\subsubsection{\lstinline|readChromosomeFromFile()| \& \lstinline|writeChromosomeToFile()|}
+			
+				These methods are simple utility methods for reading and writing chromosomes from and to \lstinline|CacheHandler*.dn| files.
+			
+			\subsubsection{\lstinline|hasSubTrees()|}
+			
+				This method returns a boolean indicating whether a passed chromosome has nested expressions or not.
+			
+			\subsubsection{\lstinline|main()|}
+			
+				The \lstinline|main()| method takes the $n$ candidates of previous generation $m$ (passed to it as arguments) and selects the top 10 \% of them to go across unchanged to generation $m+1$. Of the remainder, probabilities of mutation and crossover are applied to each and, when those occur, separate probabilities determine the type of mutation or crossover that will occur.
+				
+		\subsection{\lstinline|cachingpolicy/config.conf|}
+			
+			\lstinline|mutator.py| reads in its probability values from the file \lstinline|config.conf|.\footnote{For an example \lstinline|config.conf|, see Appendix \ref{appendix:settings}} This file contains a number of name-value pairs. The left hand side of each config. pair is ignored by \lstinline|mutator.py| and is thus present only for the aid of the human user.
+
+	\newpage
+	
+	\section{The System in Operation}
+	
+		In this section is outlined the process of creating a new module---and running a suit of tests using it---via the EmerGen(e)tic framework.
+			
+		\subsection{Creating a Module}
+			
+			\subsubsection{Files}
+			
+				To create a new module for a future research project, create the folder within the \lstinline|project| directory. Within this directory, create a Python file \lstinline|mutator.py|, which will contain all of your genetic algorithm and a Bashscript file \lstinline|setup.sh| to perform any functions prior to each test such as creating or deleting folders (this may not perform any tasks, but the file must still be present).\footnote{For an example \lstinline|setup.sh|, see Appendix \ref{appendix:setup}}
+
+			\subsubsection{Implementation}
+			
+				To implement the new module and test the results of it, code must be written within the \lstinline|runCandidate()| method of the Dana file \lstinline|emergenetic.dn|. Within this method will be defined the process of testing, how to use script files and the metric by which success is measured. The other methods within the file will remain unchanged.
+					
+		\subsection{Creating Scripts}
+		
+			In order to run a suite of different tests for each candidate, scripts are required. In the \lstinline|cachingpolicy| instance, these script files contain the filenames of different files grouped by some property or properties. For example, \lstinline|difffile-html.script| tests a number of different files, all of which are HTML but are a mixture of sizes, whilst \lstinline|difffile.script| tests different files that are a mixture of HTML and image and have a range of sizes. This can be used to easily showcase the system producing different results that provide optimum behaviour based on different operational conditions.
+						
+		\subsection{Running EmerGen(e)tic}
+		
+			After compiling the \lstinline|emergenetic.dn| file, the program can be run. It expects four command-line arguments, and can take a fifth optional one. The command is as follows:
+			\begin{lstlisting}[language=bash]
+				dana emergenetic <module> <script> <generations> <candidates> [verbose]
+			\end{lstlisting}
+			\lstinline|<module>| is the name of the module folder that you wish to use for your tests.\\
+			\lstinline|<script>| is the name of the script file for this particular test, located within the \lstinline|/scripts/| directory and without the trailing \lstinline|.script| file extension. For example, ``\lstinline|difffile|" for the script file \lstinline|difffile.script|.\\
+			The \lstinline|<generations>| and \lstinline|<candidates>| arguments are the number of generations to run the test for, and the number of candidates to produce per generation.\\
+			The optional \lstinline|verbose| argument, if present, produces far more verbose output text. This can be useful for debugging.\\
+			For example, below is the console output for a typical run of the \lstinline|cachingpolicy| module (with the \lstinline|verbose| flag omitted):
+			\begin{lstlisting}
+				ben@metacom-1:~/emergenetic$ dana emergenetic cachingpolicy difffile 10 10
+	
+				Response time for configuration 0x0: 19 ms
+				Response time for configuration 0x1: 20 ms
+				Response time for configuration 0x2: 20 ms
+				Response time for configuration 0x3: 19 ms
+				Response time for configuration 0x4: 20 ms
+				Response time for configuration 0x5: 19 ms
+				Response time for configuration 0x6: 20 ms
+				Response time for configuration 0x7: 19 ms
+				Response time for configuration 0x8: 19 ms
+				Response time for configuration 0x9: 20 ms
+				
+				Response time for configuration 1x0: 20 ms
+				Response time for configuration 1x1: 20 ms
+				Response time for configuration 1x2: 19 ms
+				Response time for configuration 1x3: 19 ms
+				Response time for configuration 1x4: 19 ms
+				Response time for configuration 1x5: 19 ms
+				Response time for configuration 1x6: 20 ms
+				Response time for configuration 1x7: 20 ms
+				Response time for configuration 1x8: 19 ms
+				Response time for configuration 1x9: 19 ms
+				
+				Response time for configuration 2x0: 20 ms
+				Response time for configuration 2x1: 19 ms
+				Response time for configuration 2x2: 20 ms
+				Response time for configuration 2x3: 20 ms
+			\end{lstlisting}
+			...and so on. Here is a sample of console output with the \lstinline|verbose| flag included:
+			\begin{lstlisting}
+				ben@metacom-1:~/emergenetic$ dana emergenetic cachingpolicy difffile 10 10 verbose
+				
+				Response time for configuration 0x0: 20 ms
+				Response time for configuration 0x1: 19 ms
+				Response time for configuration 0x2: 19 ms
+				Response time for configuration 0x3: 19 ms
+				Response time for configuration 0x4: 19 ms
+				Response time for configuration 0x5: 20 ms
+				Response time for configuration 0x6: 20 ms
+				Response time for configuration 0x7: 19 ms
+				Response time for configuration 0x8: 20 ms
+				Response time for configuration 0x9: 20 ms
+				
+				Applying rank selection to top 10% from prev. generation...
+				        Result: 0_2 copied to 1_2
+				
+				Mutating 0_3->1_3:
+				        Mutating: 0
+				                Result: 0*0
+				        Mutating: 0*0
+				                Result: 0/0
+				        Mutating: 0/0
+				                Result: 0/random()
+				0_3->1_3 mutation finish.
+				
+				Mutating 0_4->1_4:
+				        Mutating: 0
+				                Result: 0*1
+				        Mutating: 0*1
+				                Result: 0*1
+				        Mutating: 0*1
+				                Result: 0*nthMostFrequentlyUsed(0)
+				0_4->1_4 mutation finish.
+				
+				Mutating 0_5->1_5:
+				        Mutating: 0
+				                Result: 0-1
+				        Mutating: 0-1
+				                Result: 0-1
+				        Mutating: 0-1
+				                Result: 0-17
+				0_5->1_5 mutation finish.
+			
+				Response time for configuration 1x0: 19 ms
+				Response time for configuration 1x1: 29 ms
+			\end{lstlisting}
+			...and so on.
+			
+		\subsection{Background Tests}
+		
+			The process can be run as a background process so that the Terminal window/SSH connection can be closed by the user without interrupting the tests. The user can either run the EmerGen(e)tic program itself as a background process, or write a script to run.\footnote{An example script can be seen in Appendix \ref{appendix:bash}} To run the process in the background, use the commands
+			\begin{lstlisting}[language=bash]
+				dana emergenetic cachingpolicy difffile 10 10 &>/dev/null &
+				disown
+			\end{lstlisting}
+			By redirecting output to \lstinline|output.txt| rather than \lstinline|/dev/null|, the user can also track the progress of the tests as they happen.
+	
+	\newpage
+		
+	\section{Testing \& Evaluation}
+	\label{sec:testing}
+	
+		In this section is outlined the results of various testing of the system. Following that, the successes and failures of the project will be reviewed and how well it satisfies the research goals outlined in \S \ref{sec:introduction} assessed.
+		
+		\subsection{Testing EmerGen(e)tic}
+		
+			The first test was one to make sure that the EmerGen(e)tic program was working as expected. Using a very simple \lstinline|helloworld| module (that simply took a \lstinline|.txt| file containing the line `Hello world' and applied a random chance of mutating the letters into others), three tests were run.\footnote{See Appendix \ref{appendix:helloworld}}\\
+			The first test, with mutation probability set to 50 \%, produced the following output:
+			\lstinputlisting[lastline=15]{../dat/helloworld/output50.txt}
+			\begin{lstlisting}
+			[...]
+			\end{lstlisting}
+			\lstinputlisting[firstline=60,lastline=65]{../dat/helloworld/output50.txt}
+			As you can see, mutations were successfully applied to some (but not all) candidates on each generation's run, with the generations further from 0 being progressively less recognisable from their origins.\\
+			In order to test that the system worked too with varying probability values, tests were run with probability values of 0 \% and 100 \%.\\
+			For 0 \%, the results were as follows:
+			\lstinputlisting[lastline=20]{../dat/helloworld/output0.txt}
+			\begin{lstlisting}
+			[...]
+			\end{lstlisting}
+			\lstinputlisting[firstline=60,lastline=65]{../dat/helloworld/output0.txt}
+			This shows that no mutation operations were applied.\\
+			For 100 \%, the results were as follows:
+			\lstinputlisting[lastline=20]{../dat/helloworld/output100.txt}
+			\begin{lstlisting}
+			[...]
+			\end{lstlisting}
+			\lstinputlisting[firstline=60,lastline=65]{../dat/helloworld/output100.txt}
+			This shows that the mutations were applied to every single letter of every single candidate.\\
+			From these, EmerGen(e)tic is shown to be able successfully implement genetic algorithms and tests thereof. Also, the speed at which modules can be developed is demonstrated: \lstinline|helloworld| took around 15 mins to write.\\
+		
+		\subsection{Testing \lstinline|cachingpolicy|}
+		\label{sec:testingcache}
+		
+			\begin{wrapfigure}{l}{0.46\textwidth}
+				\vspace{-20pt}
+			  	\begin{center}
+			    	\includegraphics[width=0.44\textwidth]{difffile-large}
+					\vspace{-20pt}
+			  		\caption{}
+					\label{fig:difffile-large}
+			    	\includegraphics[width=0.44\textwidth]{difffile-large-wo}
+					\vspace{-20pt}
+			  		\caption{}
+					\label{fig:difffile-large-wo}
+			    	\includegraphics[width=0.44\textwidth]{samefile-images}
+					\vspace{-20pt}
+			  		\caption{}
+					\label{fig:samefile-images}
+			    	\includegraphics[width=0.44\textwidth]{samefile-images-wo}
+					\vspace{-20pt}
+			  		\caption{}
+					\label{fig:samefile-images-wo}
+			  	\end{center}
+				\vspace{-10pt}
+			\end{wrapfigure}
+			With EmerGen(e)tic itself having been demonstrated to work, answering the research questions posed in the introduction to this project could be attempted. The first question was phrased `can genetic algorithms be productively used to produce optimum components for an emergent system?'\\
+			To test this hypothesis, the initial probability variables in \lstinline|config.conf| were set to the values shown in Appendix \ref{appendix:settings}---the probability of a complexity-increasing mutation was set so high in the hope that this would produce more rapidly a diverse spread of different chromosomes.\\
+			Tests were then run on the test suite \lstinline|difffile-large|, which requests a series of different HTML and image files, all large. Each test was run for 18 generations, consisting of a population of 35 candidates each, and repeated three times. The results were the averaged across each of the three runs. The average result per generation is visible in Figs \ref{fig:difffile-large} \& \ref{fig:difffile-large-wo}.\\
+			There were a number of anomalous results that initially made discerning a pattern difficult (e.g. candidate 14\_4 from the first run returned 410 ms). Removing any results $\geq$35 ms (only 14 out of a total of 1890 results) produced Fig. \ref{fig:difffile-large-wo}, where the trending towards faster and faster response times is more obvious. From a wider range of results for the initial few generations (21--30 ms), the components in later generations tended towards consistent level of around 21 ms response time.\\
+			It wouldn't have been surprising to see that these higher-performing chromosomes shared similar characteristics, such as all calling \lstinline|nthMostFrequentlyUsed()|. Indeed, this appears to have been somewhat the case, although not exclusively so---the chromosomes `\lstinline|11/random()|' and `\lstinline|nthMostRecentlyUsed(0)*nthMostFrequentlyUsed(0)|' each achieve 21 ms, as did a range of other chromosomes. However, the most common characteristic of all of the generation 18 chromosomes seemed to be the presence of one or both of the \lstinline|nthMost*Used()| functions---29 out of the 38 chromosomes featured one of these functions, and 8 featured both.\footnote{To view all of the gen. 18 chromosomes, see Appendix \ref{appendix:chromosomes}}\\
+			The test suite \lstinline|samefile-images|---which requests the same image file repeatedly---was then run with the same conditions. The results are visible in figs \ref{fig:samefile-images} and \ref{fig:samefile-images-wo}.\\
+			There is no visible improvement in either of these charts. Barring two anomalous results, the response times only varied between 18 and 19 ms, suggesting that no amount of mutation made a difference on performance. This was expected, however---after enough runs, every index in the cache will point to identical data and the formula for updating the cache will be meaningless.
+	
+		\subsection{Evaluation}
+		\label{sec:eval}
+			
+			The research aim specified for EmerGen(e)tic was `to produce a framework for enabling rapid development of genetic improvement tests'. This has been done---EmerGen(e)tic is simple to extend with new modules, being written in the more widely-known Python language (rather than the admittedly more niche Dana). Given a blank copy of EmerGen(e)tic and this report, it is confidently assumed that a researcher could begin deploying their own tests in minimal time. To support this claim, the \lstinline|helloworld| and \lstinline|cachingpolicy| modules were developed to demonstrate the framework in action.\\
+			The \lstinline|cachepolicy| module (initially) produced results that appear to support the assertion made in \S \ref{sec:introduction}---i.e. that genetic algorithms can be usefully applied to the creation of emergent system components. As was expected too, this is not the case for all contexts (e.g. \lstinline|samefile-images|), which demonstrates that in some instances, the added overhead of running genetic algorithm generations is not rewarded with any tangible improvements.\\
+			However, perhaps a scope that would have produced more variance than just cache updating behaviour would have been advisable to choose at the start of the project in order to better prove or disprove this hypothesis. As it stands, a proof, albeit a slightly weak proof, is nonetheless provided.\\
+			An additional aim was set, to `repeat the tests multiple times with a variety of conditions and see what, if any, trends emerge.' However, between the tests featured in \S\ref{sec:testingcache} and when the condition-variance tests were due to be run, access to the research computer was temporarily suspended. Upon returning to it a week later, test runs (even those with identical conditions to the ones previously performed) no longer produced meaningful results---response times barely varied for all tests run, regardless of number of generations.\\
+			To make sure that this was not a result of the machine's processing speed increasing and minor changes in response time being undetectable, all of the test suites were tripled in length in the hope that minor changes would become more pronounced. Unfortunately this had no effect, and at this late stage in the project no alternative was left but to cease testing of the \lstinline|cachepolicy| module.\\
+			However, the approaches that would have been taken will be outlines in the `Future Improvements' section at the end of this report.
+			
+	\newpage
+	
+	\section{Conclusion}
+
+		In \S \ref{sec:introduction}, two research questions were established. In this section, the answers provided will be considered. Then, suggestions for further research will be outlined.\\
+		
+		\noindent\textbf{Can genetic algorithms can be productively used to produce optimum components for an emergent system?}\\
+		
+		\noindent This has been shown to be the case. The response times for delivery of certain types of files have been demonstrated steadily decreasing per generation following application of genetic algorithms. However, it has also been shown that there are some instances where genetic algorithms are of little use (e.g. when the same file is requested from the web server repeatedly). In these cases, the overhead of running the genetic algorithm (and each generation takes a non-trivial amount of time to produce, compile and test) is not rewarded.\\
+		
+		\noindent\textbf{What are the optimal conditions for doing so (i.e. mutation probabilities, generation sizes, etc.)?}\\
+			
+		\noindent As explained in \S\ref{sec:eval}, issues that emerged late in the project prohibited exploration of this area.
+		
+		\subsection{Future Development}
+		
+			\subsubsection{Completing the original goal of finding the optimal conditions for the genetic algorithm}
+			
+				As previously mentioned, issues prevented this avenue of research from being explored. If these issues were resolved, it would be useful to revisit this second research question. The intended plan was to set the probabilities of the four specific mutation operations to 50 \%, run a test suite with mutation and crossover probabilities set at each 10-step interval (i.e. 0 \%, 10 \%, $\dots$ , 100 \%) and compare results to determine the optimum probabilities of both. This could then be re-run with the probabilities set at opposing ends (i.e. 0\% and 100 \%) and converging towards and then past each other---this would hypothetically display whether similar or distinct probabilities for the two operations (if either) are more desirable.\\
+				After these tests have hopefully shown a broad region of optimal probabilities, more fine-grained testing within that region could then take place. This could involve testing the original two probabilities with a range of values across a smaller step size, or testing different combinations of probabilities for the four specific mutation operations. For example, all but one could be set to 0 \% and this used to determine how well they work in isolation.
+		
+			\subsubsection{Designing more modules}
+			
+				For a future project or projects, one could develop and run different tests using the EmerGen(e)tic framework provided here. For example, a module that applied genetic algorithms to the file compression options including in Filho \& Porter's original web server. Alternatively, such a module could be combined with another (such as \lstinline|cachingpolicy|) in order to test a broader scope of mutation than just individual functionality and demonstrate the potential interlinked effects of this.
+				
+			\subsubsection{A more `Danatically'-designed EmerGen(e)tic}
+			
+				When running an EmerGen(e)tic module in which the genetic algorithm is improperly implemented, and thus can produce uncompilable components, the compilation attempt will fail for that component and the entire EmerGen(e)tic test run/suite fail upon trying to load the non-existent component object file that has thus not been produced. Dana lacks exception-handling functionality, as a component's failure is intended to be signalled to the calling component via a \lstinline|return|. By re-designing the system in a more idiomatically Dana way and calling the tests as a separate component rather than in the \lstinline|runCandidate()| method of \lstinline|emergenetic.dn|, failure of an individual test could be ignored and the test runs continued.\\
+				Another benefit of this would be the complete separation of the functionality currently within \lstinline|runCandidate()|, which module developers must edit in order to implement their modules, and the remainder of the \lstinline|emergenetic.dn| file, which they should no have cause to touch. As it stands, the \lstinline|cachingpolicy| module contains a copy of \lstinline|emergenetic.dn| with the \lstinline|runCandidates()| implementation within it, which overwrites the existing \lstinline|emergenetic.dn| within the base distribution. This raises issues---if a module is written for a specific version of \lstinline|emergenetic.dn|, upgrading it would result in extra, unnecessary workload for the developer. However, if the \lstinline|runCandidate()| functionality could thus be moved into a separate \lstinline|runCandidate.dn| file, then issues with EmerGen(e)tic versions would be resolved. Also, this would allow EmerGen(e)tic to be distributed as a black box API, without having to distribute source files (although, as the software is released under the GNU GPLv3, this last point is less relevant), as well as allowing a user to install multiple modules simultaneously.
+				
+			\subsubsection{Issues within the present \lstinline|cachingpolicy| module}
+			
+				Besides the issues that prohibited testing for optimum conditions, there were a couple other outstanding issues within the \lstinline|cachingpolicy| modules that could be fixed in the future.\\
+				Foremost of these is that test runs will sometimes, with what appears to be no predictability, stop outputting just after finishing a generation but continue to run, draining system resources until the process is killed. \lstinline|python| can be seen to still be running which, along with the stage in the process where the issue occurs and the lack of an output error message, suggests that the fault may lie in the \lstinline|cachingpolicy| module. The nature of the issue would further suggest an endless loop occurring somewhere---thus, suspicions fall upon the \lstinline|while| loop within the \lstinline|crossover()| method, or the recursive elements of the \lstinline|crossover()| and \lstinline|mutation()| methods.
+				
+			\subsubsection{Putting human developers further out of work (through meta-learning)}
+			
+				Finally, and potentially the most interesting avenue for further research of the system based on the problem it set out to fix (as outlined in \S \ref{sec:introduction}): meta-learning.\cite{meta} In this case, the system would have an ability not just to rank candidates by a predefined metric (in \lstinline|cachingpolicy|'s case the response time in ms), but also to change its metric using the same principles of genetic improvement. Despite removing the human developer from much of the software development via the implementation of genetic algorithms, one is still required to write those algorithms and, most egregiously, outline the metric(s) by which performance is measured. If the system could be left to improve its own algorithm and, if a candidate was found, amend how it judges success of candidates, the goal of the programmerless system will have been even further achieved.
+		
+	\newpage
+	
+	\bibliographystyle{IEEEtran}
+	\bibliography{final-report}	
+	
+	\newpage
+	
+	\appendices
+	
+		\section{\lstinline|emergenetic.dn|}
+		\label{appendix:emergen}
+		\lstinputlisting[language=Java]{../src/emergenetic/emergenetic.dn}
+	
+		\newpage
+		
+		\section{\lstinline|helloworld/mutator.py|}
+		\label{appendix:helloworld}
+		\lstinputlisting[language=Python]{../src/helloworld/project/helloworld/mutator.py}
+			
+		\newpage
+		
+		\section{\lstinline|cachingpolicy|}
+			\subsection{\lstinline|CacheHandlerBase.dn|}
+			\label{appendix:base}
+			\lstinputlisting[language=Java]{../src/cachingpolicy/cachebackup/CacheHandlerBase.dn}
+			
+			\newpage
+			
+			\subsection{\lstinline|mutator.py|}
+			\label{appendix:genetic}
+			\lstinputlisting[language=Python]{../src/cachingpolicy/project/cachingpolicy/mutator.py}
+			
+			\subsection{\lstinline|emergenetic.dn|'s \lstinline|runCandidates()| method}
+			\label{appendix:runcand}
+			\lstinputlisting[language=Java, firstline=131, lastline=173]{../src/cachingpolicy/emergenetic.dn}
+			
+			\subsection{\lstinline|setup.sh|}
+			\label{appendix:setup}
+			\lstinputlisting[language=bash]{../src/cachingpolicy/project/cachingpolicy/setup.sh}
+			
+			\subsection{\lstinline|config.conf|}
+			\label{appendix:settings}
+			\lstinputlisting{../src/cachingpolicy/project/cachingpolicy/config.conf}
+			
+			\subsection{Gen. 18 chromosomes}
+			\label{appendix:chromosomes}
+			\lstinputlisting[language=Java]{../dat/cache/difffile-large/17/chromosomes.txt}
+		
+		\newpage
+		
+		\section{\lstinline|runTests.sh|}
+		\label{appendix:bash}
+		\lstinputlisting[language=bash]{../dat/runTests.sh}
+
+\end{document}
\ No newline at end of file
diff --git a/report/img/Thumbs.db b/report/img/Thumbs.db
new file mode 100644
index 0000000..2b96f46
Binary files /dev/null and b/report/img/Thumbs.db differ
diff --git a/report/img/difffile-large-wo.png b/report/img/difffile-large-wo.png
new file mode 100644
index 0000000..33a607c
Binary files /dev/null and b/report/img/difffile-large-wo.png differ
diff --git a/report/img/difffile-large.png b/report/img/difffile-large.png
new file mode 100644
index 0000000..dd173db
Binary files /dev/null and b/report/img/difffile-large.png differ
diff --git a/report/img/samefile-images-wo.png b/report/img/samefile-images-wo.png
new file mode 100644
index 0000000..0d773ce
Binary files /dev/null and b/report/img/samefile-images-wo.png differ
diff --git a/report/img/samefile-images.png b/report/img/samefile-images.png
new file mode 100644
index 0000000..70c7df0
Binary files /dev/null and b/report/img/samefile-images.png differ
diff --git a/src/cachingpolicy/LICENSE.md b/src/cachingpolicy/LICENSE.md
new file mode 100644
index 0000000..2a99aee
--- /dev/null
+++ b/src/cachingpolicy/LICENSE.md
@@ -0,0 +1,675 @@
+### GNU GENERAL PUBLIC LICENSE
+
+Version 3, 29 June 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc.
+<http://fsf.org/>
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+### Preamble
+
+The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom
+to share and change all versions of a program--to make sure it remains
+free software for all its users. We, the Free Software Foundation, use
+the GNU General Public License for most of our software; it applies
+also to any other work released this way by its authors. You can apply
+it to your programs, too.
+
+When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights. Therefore, you
+have certain responsibilities if you distribute copies of the
+software, or if you modify it: responsibilities to respect the freedom
+of others.
+
+For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received. You must make sure that they, too, receive
+or can get the source code. And you must show them these terms so they
+know their rights.
+
+Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software. For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the
+manufacturer can do so. This is fundamentally incompatible with the
+aim of protecting users' freedom to change the software. The
+systematic pattern of such abuse occurs in the area of products for
+individuals to use, which is precisely where it is most unacceptable.
+Therefore, we have designed this version of the GPL to prohibit the
+practice for those products. If such problems arise substantially in
+other domains, we stand ready to extend this provision to those
+domains in future versions of the GPL, as needed to protect the
+freedom of users.
+
+Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish
+to avoid the special danger that patents applied to a free program
+could make it effectively proprietary. To prevent this, the GPL
+assures that patents cannot be used to render the program non-free.
+
+The precise terms and conditions for copying, distribution and
+modification follow.
+
+### TERMS AND CONDITIONS
+
+#### 0. Definitions.
+
+"This License" refers to version 3 of the GNU General Public License.
+
+"Copyright" also means copyright-like laws that apply to other kinds
+of works, such as semiconductor masks.
+
+"The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of
+an exact copy. The resulting work is called a "modified version" of
+the earlier work or a work "based on" the earlier work.
+
+A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user
+through a computer network, with no transfer of a copy, is not
+conveying.
+
+An interactive user interface displays "Appropriate Legal Notices" to
+the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+#### 1. Source Code.
+
+The "source code" for a work means the preferred form of the work for
+making modifications to it. "Object code" means any non-source form of
+a work.
+
+A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+The Corresponding Source need not include anything that users can
+regenerate automatically from other parts of the Corresponding Source.
+
+The Corresponding Source for a work in source code form is that same
+work.
+
+#### 2. Basic Permissions.
+
+All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+You may make, run and propagate covered works that you do not convey,
+without conditions so long as your license otherwise remains in force.
+You may convey covered works to others for the sole purpose of having
+them make modifications exclusively for you, or provide you with
+facilities for running those works, provided that you comply with the
+terms of this License in conveying all material for which you do not
+control copyright. Those thus making or running the covered works for
+you must do so exclusively on your behalf, under your direction and
+control, on terms that prohibit them from making any copies of your
+copyrighted material outside their relationship with you.
+
+Conveying under any other circumstances is permitted solely under the
+conditions stated below. Sublicensing is not allowed; section 10 makes
+it unnecessary.
+
+#### 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such
+circumvention is effected by exercising rights under this License with
+respect to the covered work, and you disclaim any intention to limit
+operation or modification of the work as a means of enforcing, against
+the work's users, your or third parties' legal rights to forbid
+circumvention of technological measures.
+
+#### 4. Conveying Verbatim Copies.
+
+You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+#### 5. Conveying Modified Source Versions.
+
+You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these
+conditions:
+
+-   a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+-   b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under
+    section 7. This requirement modifies the requirement in section 4
+    to "keep intact all notices".
+-   c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy. This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged. This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+-   d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+#### 6. Conveying Non-Source Forms.
+
+You may convey a covered work in object code form under the terms of
+sections 4 and 5, provided that you also convey the machine-readable
+Corresponding Source under the terms of this License, in one of these
+ways:
+
+-   a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+-   b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the Corresponding
+    Source from a network server at no charge.
+-   c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source. This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+-   d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge. You need not require recipients to copy the
+    Corresponding Source along with the object code. If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source. Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+-   e) Convey the object code using peer-to-peer transmission,
+    provided you inform other peers where the object code and
+    Corresponding Source of the work are being offered to the general
+    public at no charge under subsection 6d.
+
+A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal,
+family, or household purposes, or (2) anything designed or sold for
+incorporation into a dwelling. In determining whether a product is a
+consumer product, doubtful cases shall be resolved in favor of
+coverage. For a particular product received by a particular user,
+"normally used" refers to a typical or common use of that class of
+product, regardless of the status of the particular user or of the way
+in which the particular user actually uses, or expects or is expected
+to use, the product. A product is a consumer product regardless of
+whether the product has substantial commercial, industrial or
+non-consumer uses, unless such uses represent the only significant
+mode of use of the product.
+
+"Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to
+install and execute modified versions of a covered work in that User
+Product from a modified version of its Corresponding Source. The
+information must suffice to ensure that the continued functioning of
+the modified object code is in no case prevented or interfered with
+solely because modification has been made.
+
+If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or
+updates for a work that has been modified or installed by the
+recipient, or for the User Product in which it has been modified or
+installed. Access to a network may be denied when the modification
+itself materially and adversely affects the operation of the network
+or violates the rules and protocols for communication across the
+network.
+
+Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+#### 7. Additional Terms.
+
+"Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders
+of that material) supplement the terms of this License with terms:
+
+-   a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+-   b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+-   c) Prohibiting misrepresentation of the origin of that material,
+    or requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+-   d) Limiting the use for publicity purposes of names of licensors
+    or authors of the material; or
+-   e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+-   f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions
+    of it) with contractual assumptions of liability to the recipient,
+    for any liability that these contractual assumptions directly
+    impose on those licensors and authors.
+
+All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions; the
+above requirements apply either way.
+
+#### 8. Termination.
+
+You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+However, if you cease all violation of this License, then your license
+from a particular copyright holder is reinstated (a) provisionally,
+unless and until the copyright holder explicitly and finally
+terminates your license, and (b) permanently, if the copyright holder
+fails to notify you of the violation by some reasonable means prior to
+60 days after the cessation.
+
+Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+#### 9. Acceptance Not Required for Having Copies.
+
+You are not required to accept this License in order to receive or run
+a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+#### 10. Automatic Licensing of Downstream Recipients.
+
+Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+#### 11. Patents.
+
+A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+A contributor's "essential patent claims" are all patent claims owned
+or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+A patent license is "discriminatory" if it does not include within the
+scope of its coverage, prohibits the exercise of, or is conditioned on
+the non-exercise of one or more of the rights that are specifically
+granted under this License. You may not convey a covered work if you
+are a party to an arrangement with a third party that is in the
+business of distributing software, under which you make payment to the
+third party based on the extent of your activity of conveying the
+work, and under which the third party grants, to any of the parties
+who would receive the covered work from you, a discriminatory patent
+license (a) in connection with copies of the covered work conveyed by
+you (or copies made from those copies), or (b) primarily for and in
+connection with specific products or compilations that contain the
+covered work, unless you entered into that arrangement, or that patent
+license was granted, prior to 28 March 2007.
+
+Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+#### 12. No Surrender of Others' Freedom.
+
+If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under
+this License and any other pertinent obligations, then as a
+consequence you may not convey it at all. For example, if you agree to
+terms that obligate you to collect a royalty for further conveying
+from those to whom you convey the Program, the only way you could
+satisfy both those terms and this License would be to refrain entirely
+from conveying the Program.
+
+#### 13. Use with the GNU Affero General Public License.
+
+Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+#### 14. Revised Versions of this License.
+
+The Free Software Foundation may publish revised and/or new versions
+of the GNU General Public License from time to time. Such new versions
+will be similar in spirit to the present version, but may differ in
+detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies that a certain numbered version of the GNU General Public
+License "or any later version" applies to it, you have the option of
+following the terms and conditions either of that numbered version or
+of any later version published by the Free Software Foundation. If the
+Program does not specify a version number of the GNU General Public
+License, you may choose any version ever published by the Free
+Software Foundation.
+
+If the Program specifies that a proxy can decide which future versions
+of the GNU General Public License can be used, that proxy's public
+statement of acceptance of a version permanently authorizes you to
+choose that version for the Program.
+
+Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+#### 15. Disclaimer of Warranty.
+
+THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT
+WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND
+PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
+DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
+CORRECTION.
+
+#### 16. Limitation of Liability.
+
+IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR
+CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
+ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT
+NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR
+LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM
+TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER
+PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+#### 17. Interpretation of Sections 15 and 16.
+
+If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+END OF TERMS AND CONDITIONS
+
+### How to Apply These Terms to Your New Programs
+
+If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these
+terms.
+
+To do so, attach the following notices to the program. It is safest to
+attach them to the start of each source file to most effectively state
+the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+        <one line to give the program's name and a brief idea of what it does.>
+        Copyright (C) <year>  <name of author>
+
+        This program 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/>.
+
+Also add information on how to contact you by electronic and paper
+mail.
+
+If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+        <program>  Copyright (C) <year>  <name of author>
+        This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+        This is free software, and you are welcome to redistribute it
+        under certain conditions; type `show c' for details.
+
+The hypothetical commands \`show w' and \`show c' should show the
+appropriate parts of the General Public License. Of course, your
+program's commands might be different; for a GUI interface, you would
+use an "about box".
+
+You should also get your employer (if you work as a programmer) or
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. For more information on this, and how to apply and follow
+the GNU GPL, see <http://www.gnu.org/licenses/>.
+
+The GNU General Public License does not permit incorporating your
+program into proprietary programs. If your program is a subroutine
+library, you may consider it more useful to permit linking proprietary
+applications with the library. If this is what you want to do, use the
+GNU Lesser General Public License instead of this License. But first,
+please read <http://www.gnu.org/philosophy/why-not-lgpl.html>.
\ No newline at end of file
diff --git a/src/cachingpolicy/README.md b/src/cachingpolicy/README.md
new file mode 100644
index 0000000..ed9d502
--- /dev/null
+++ b/src/cachingpolicy/README.md
@@ -0,0 +1,32 @@
+# CachingPolicy 1.0         
+
+## License
+
+This EmerGen(e)tic module is copyright © 2017 Ben Goldsworthy (rumperuu).
+                                                                          
+CachingPolicy 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.                                        
+                                                                           
+CachingPolicy 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 CachingPolicy.  If not, see <http://www.gnu.org/licenses/>.                             
+
+## Contact
+
+Email: me@bengoldsworthy.uk
+
+## Description
+
+CachingPolicy is an EmerGen(e)tic module for testing the use of genetic
+algorithms as applied to the cache updating behaviour of a web server.
+
+## Installation
+
+Copy everything in this directory into your EmerGen(e)tic directory. Then,
+run the Terminal command `chmod +x ./project/cachingpolicy/setup.sh`.
diff --git a/src/cachingpolicy/cachebackup/CacheHandlerBase.dn b/src/cachingpolicy/cachebackup/CacheHandlerBase.dn
new file mode 100644
index 0000000..93a30db
--- /dev/null
+++ b/src/cachingpolicy/cachebackup/CacheHandlerBase.dn
@@ -0,0 +1,278 @@
+/*
+ *                       CachingPolicy 0.9                     
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * CachingPolicy is an EmerGen(e)tic module for testing the use of genetic
+ * algorithms as applied to the cache updating behaviour of a web server.
+ *                                                                           
+ * This file is part of the CachingPolicy EmerGen(e)tic module.                           
+ *                                                                             
+ * CachingPolicy 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.                                        
+ *                                                                            
+ * CachingPolicy 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 CachingPolicy.  If not, see <http://www.gnu.org/licenses/>.                             
+ */
+
+/**
+ ** This program serves as the base for each mutated CacheHandler,
+ ** providing the functionality that is common to all of them.
+ **/
+
+/**
+ **   @author  Ben Goldsworthy (rumperuu) <me@bengoldsworthy.uk>
+ **   @version 0.9
+ **/
+component provides cache.CacheHandler 
+          requires io.Output out, 
+                   data.IntUtil iu, 
+                   util.RandomInt ir, 
+                   time.Calendar ic, 
+                   time.DateUtil du, 
+                   io.File {
+                         
+	static CachedResponse cache[]
+	static int arraySize
+	static Mutex cacheLock
+
+   /**
+    **   Returns a requested item from the cache.
+    **
+    **   @param resource The request item filepath
+    **   @return The item from the cache
+    **/
+	CachedResponse CacheHandler:getCachedResponse(char filePath[]) {
+      // Converts the filepath to an array of bytes for the file.
+      File fd = new File(filePath, File.FILE_ACCESS_READ)
+      char resource[] = fd.read(fd.getSize())
+      fd.close()
+      
+      // Returns the item if it's in the cache.
+		mutex(cacheLock) {						
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == resource) {
+					cache[i].hits++
+					cache[i].lastUsed = ic.getTime()
+					return cache[i]
+				}
+			}
+		}		
+		return null
+	}
+	
+	/**
+	 **   Updates the cache if the requested item is not already present.
+	 **   If the cache is full, the method of determining the item to be 
+	 **   replaced is subject to genetic mutation.
+	 **
+	 **   @param ncr The new item to cache
+	 **/
+	void CacheHandler:updateCache(CachedResponse ncr) {
+		mutex(cacheLock) {	
+		    // If the item is already in the cache, do nothing.
+			for (int i = 0; i < arraySize; i++) {
+				if (cache[i].resource == ncr.resource) {
+					cache[i].response = ncr.response
+					cache[i].resourceAge = ncr.resourceAge
+
+					return
+				}
+			}
+			
+			// If the item is not, it must be added.
+			// As `ncr` was created on another component, its details must
+			// be copied to avoid a read-only exception.
+			CachedResponse newEntry = new CachedResponse()
+			newEntry.command = ncr.command
+			newEntry.resource = ncr.resource
+			newEntry.resourceAge = ncr.resourceAge
+			newEntry.mimeType = ncr.mimeType
+			newEntry.response = new byte[](ncr.response)
+			newEntry.contentSize = ncr.contentSize
+
+         // Initialises the cache if there isn't currently one.
+			if (cache == null) {
+				cache = new CachedResponse[CacheHandler.MAX_SIZE]()
+			}
+
+         // If the cache is full, determines which item to replace.
+			if (arraySize == CacheHandler.MAX_SIZE) {
+				int index
+            
+				// BEGIN
+            index = 0
+				// END
+            
+				cache[index % arraySize] = newEntry
+				//out.println("$(debugMSG) replacing: $(iu.intToString(index))")
+			// Otherwise, appends the item to the end of the cache.
+			} else {
+				cache[arraySize] = newEntry
+				arraySize++
+			}
+		}
+	}
+
+    /**
+     **     Clears the cache completely.
+     **/
+	void CacheHandler:clearCache() {
+		mutex(cacheLock) {
+			cache = null
+		}
+	}
+	
+	/**************************************************************************
+	 * What follows are utility functions that a given chromosome of the
+	 * `updateCache()` method may or may not call upon.
+	 **************************************************************************/
+	
+	// This method returns the index of the nth most frequently-used item in 
+	// the cache.
+	int nthMostFrequentlyUsed(int n) {
+	   int hits[]
+	   for (int i = 0; i < arraySize; i++) hits[i] = 0
+	   
+      int i
+      int j
+	   mutex(cacheLock) {	
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (cache[i].hits == hits[j]) break
+				   else if (hits[j] == 0) {
+				      hits[j] = cache[i].hits
+				      break
+               }
+				}
+			}
+		}		
+		
+      int k = 0
+      int nthHit = 0
+		for (i = 0; i < j; i++) {
+         if (hits[i] > nthHit) {
+            nthHit = hits[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+		   j = 0					
+			for (i = 0; i < arraySize; i++) {
+			   if (cache[i].hits == nthHit) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns the index of the nth most recently-used item in 
+	// the cache.
+	int nthMostRecentlyUsed(int n) {
+	   DateTime useTimes[]
+      DateTime testTime = ic.getTime()
+	   for (int i = 0; i < arraySize; i++) useTimes[i] = testTime
+	   
+      int i
+      int j
+	   mutex(cacheLock) {						
+			for (i = 0; i < arraySize; i++) {
+				for (j = 0; j < arraySize; j++) {
+				   if (du.equal(cache[i].lastUsed, useTimes[j])) break
+				   else if (du.equal(useTimes[j], testTime)) {
+				      useTimes[j] = cache[i].lastUsed
+				      break
+               }
+				}
+			}
+		}		
+		
+		int k = 0
+      DateTime nthUseTime = ic.getTime()
+		for (i = 0; i < j; i++) {
+         if (du.after(useTimes[i], nthUseTime)) {
+            nthUseTime = useTimes[i]
+            k++
+         }
+         if (k == n) break
+      }
+		
+		int itemIndices[]
+		
+		mutex(cacheLock) {	
+         j = 0
+			for (i = 0; i < arraySize; i++) {
+			   if (du.equal(cache[i].lastUsed, nthUseTime)) itemIndices[j++] = i
+			}
+		}	
+		
+		return resolve(itemIndices, "r")	
+	}
+	
+	// This method returns a random index.
+	int random() {
+		DateTime dt = ic.getTime()
+		int msec = dt.millisecond
+		ir.setSeed(msec)
+		return ir.get(CacheHandler.MAX_SIZE)
+	}
+	
+	// This method resolves a multiple return in one of the methods above, 
+   // as per the flag sent along with the list of indices.
+	// 'n' returns the newest, 'o' the oldest and 'r' a random index.
+	int resolve(int index[], char flag) {
+		DateTime dt = null
+		
+		if (flag == "n") {
+         int newestItem = 0
+          
+         int i = index.arrayLength-1
+		   for (int j = 0; j < index.arrayLength; j++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               newestItem = index[i]
+			   } else {
+				   if (du.before(dt, cache[index[i]].timeAdded)) {
+                  dt = cache[index[i]].timeAdded
+                  newestItem = index[i]
+				   }
+			   }
+            i--
+		   }
+
+		   return newestItem
+		} else if (flag == "o") {
+		   int oldestItem = 0
+
+		   for (int i = 0; i < index.arrayLength; i++) {
+			   if (dt == null) {
+               dt = cache[index[i]].timeAdded
+               oldestItem = index[i]
+			   } else {
+				   if (du.before(cache[index[i]].timeAdded, dt)) {
+                  dt = cache[index[i]].timeAdded
+					   oldestItem = index[i]
+				   }
+			   }
+		   }
+		   return oldestItem
+		} else if (flag == "r") {
+		   dt = ic.getTime()
+		   int msec = dt.millisecond
+		   ir.setSeed(msec)
+		   return ir.get(index.arrayLength)
+	   } else {
+		   return 0
+		}
+	}
+}
diff --git a/src/cachingpolicy/emergenetic.dn b/src/cachingpolicy/emergenetic.dn
new file mode 100644
index 0000000..7a3c80c
--- /dev/null
+++ b/src/cachingpolicy/emergenetic.dn
@@ -0,0 +1,201 @@
+/*
+ *                        EmerGen(e)tic 1.0                       
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * EmerGen(e)tic is a framework for researching the use of genetic
+ * algorithms in emergent systems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                             
+ * EmerGen(e)tic 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.                                        
+ *                                                                            
+ * EmerGen(e)tic 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 EmerGen(e)tic.  If not, see <http://www.gnu.org/licenses/>.                             
+ */
+
+/**
+ ** This program runs the tests that are passed to it as command-line
+ ** arguments. It contains methods that can be easily overwritten for
+ ** creating new tests.
+ **/
+uses cache.CacheHandler
+uses data.String
+
+/**
+ **   @author  Ben Goldsworthy (rumperuu) <me@bengoldsworthy.uk>
+ **   @version 1.0
+ **/
+component provides App requires os.Run run, 
+                                   io.Output out, 
+                                   composition.Loader unloader,
+                                   composition.RecursiveLoader loader, 
+                                   time.Calendar calendar, 
+                                   time.DateUtil dateUtil, 
+                                   data.StringUtil stringUtil, 
+                                   data.IntUtil intUtil,
+                                   io.File,
+                                   io.TextFile {
+   
+   // Required arguments.
+   int argMod = 0
+   int argScript = argMod + 1
+   int argGens = argScript + 1
+   int argCans = argGens + 1
+   int minArgs = argCans + 1
+   
+   // Optional arguments.
+   int argVerb = minArgs
+   int maxArgs = minArgs + 1
+   
+   /**
+    **   Main method. Runs the generations and mutation. This method 
+    **   should not need to be modified.
+    **   
+    **   @param params The arguments the program is run with (e.g. 
+    **   the number of generations to run, and the population size per
+    **   generation, etc.)
+    **   @return The program exit code.
+    **/
+   int App:main(AppParam params[]) {
+      // Checks that there are enough passed array arguments, and that
+      // they are valid.
+      if ((params.arrayLength >= minArgs) && (params.arrayLength <= maxArgs)) {
+         if (stringUtil.isNumeric(params[argGens].string) && stringUtil.isNumeric(params[argCans].string)) {
+            // Assigns all of the command-line arguments to variables.
+            int generations = intUtil.intFromString(params[argGens].string)
+            int candidates = intUtil.intFromString(params[argCans].string)
+            char module[] = params[argMod].string
+            char script[] = params[argScript].string
+            int verbose = 0
+            if (params.arrayLength == maxArgs) {
+               if (params[argVerb].string == "verbose") {
+                  verbose = 1
+               }
+            }
+            
+            // Performs any initial setup.
+            RunStatus setupResult = run.execute("./project/$(module)/setup.sh $(intUtil.intToString(generations)) $(script)")
+            // Iterates through the generations, creating them and then
+            // testing each of their candidates.
+            for (int i = 0; i < generations; i++) {           
+               // Runs the per-generation mutator.
+               RunStatus result = run.execute("python3 ./project/$(module)/mutator.py $(intUtil.intToString(i)) $(intUtil.intToString(candidates)) $(intUtil.intToString(verbose)) $(script)")
+               // Runs the generation.
+               runGeneration(i, candidates, script)
+            }
+            
+            return 0
+         // If the 'generations' and 'candidates' arguments are non-numeric...
+         } else {
+            out.println("Invalid runtime arguments: Arguments <generation> and <candidates> must be integers.")
+            return 1
+         }
+      // If an invalid number of arguments are passed to the program...
+      } else {
+         out.println("Invalid runtime arguments: Program should be run as:\n\t`dana emergenetic <module> <script> <generations> <candidates>`\n\nProgram may also be run with optional `verbose` flag as final argument:\n\tdana emergenetic <module> <script> <generations> <candidates> verbose`")
+         return 1
+      }
+	}
+   
+   /**
+    **   Runs a generation of candidates. This method should not need to
+    **   be modified.
+    **   
+    **   @param generation The generation of the candidate.
+    **   @param candidates The total number of candidates.
+    **   @param script The name of the script file being used.
+    **/
+   void runGeneration(int generation, int candidates, char script[]) { 
+      File results
+      
+      out.println("")
+      // Runs through each candidate.
+      for (int j = 0; j < candidates; j++) runCandidate(generation, j, script)
+      
+      // For the end of the generation's candidates, appends a newline to
+      // the CSV file.
+      results = new File("./results/$(script)/results.csv", File.FILE_ACCESS_WRITE)
+      results.setPos(results.getSize())
+      results.write("\r\n")
+      results.close()
+   }
+    
+   /**
+    **   Runs a candidate through a test. Modify this method for changing
+    **   what is being tested.
+    **   
+    **   @param generation The generation of the candidate.
+    **   @param candidate The number of the candidate.
+    **   @param script The name of the script file being used.
+    **/
+   void runCandidate(int generation, int candidate, char script[]) {
+      LoadedComponents lc
+      IDC com
+      CacheHandler c
+      CachedResponse cr
+      DateTime start
+      TextFile scriptFile
+      
+      // Loads the given candidate file.
+      lc = loader.load("./cache/$(script)/$(intUtil.intToString(generation))/CacheHandler$(intUtil.intToString(generation))_$(intUtil.intToString(candidate)).o")
+      com = lc.mainComponent
+      c = new CacheHandler() from com :< CacheHandler
+      
+      start = calendar.getTime()
+      
+      // Runs all of the files within the given script file as requests.
+      scriptFile = new TextFile("./scripts/$(script).script", File.FILE_ACCESS_READ)
+      char line[] = scriptFile.readLine()
+      while (line != "") {
+         cr = c.getCachedResponse(line)
+         line = scriptFile.readLine()
+      }
+      scriptFile.close()
+      
+      // Records the response time to complete all requests and records
+      // the results.
+      int responseTime = dateUtil.toMilliseconds(dateUtil.diff(start, calendar.getTime()))
+      printResults(generation, candidate, intUtil.intToString(responseTime), "ms", script)
+      
+      // Unloads the component(s).
+      c = null
+      for (int k = 0; k < lc.loadedComponents.arrayLength; k++) {
+         unloader.unload(lc.loadedComponents[k].class)
+      }
+   }
+   
+   /**
+    **   Prints the results of a test run. This method should not need to
+    **   be modified.
+    **   
+    **   @param generation The generation of the candidate.
+    **   @param candidate The number of the candidate.
+    **   @param metric The value of the metric by which candidates are
+    **      being rated (as a string).
+    **   @param unit The unit of the value (e.g. ms, cm, etc.).
+    **   @param script The name of the script file being used.
+    **/
+   void printResults(int generation, int candidate, char metric[], char unit[], char script[]) {
+      File results
+      
+      out.println("Result for configuration $(intUtil.intToString(generation))x$(intUtil.intToString(candidate)): $(metric) $(unit)")
+      
+      results = new File("./results/$(script)/results$(intUtil.intToString(generation)).txt", File.FILE_ACCESS_WRITE)
+      results.setPos(results.getSize())
+      results.write("$(intUtil.intToString(generation))_$(intUtil.intToString(candidate)):$(metric)$(unit)\r\n")
+      results.close()
+      
+      results = new File("./results/$(script)/results.csv", File.FILE_ACCESS_WRITE)
+      results.setPos(results.getSize())
+      results.write("$(metric),")
+      results.close()
+   }
+}
\ No newline at end of file
diff --git a/src/cachingpolicy/htdocs/GenerateContent.dn b/src/cachingpolicy/htdocs/GenerateContent.dn
new file mode 100644
index 0000000..7942e37
--- /dev/null
+++ b/src/cachingpolicy/htdocs/GenerateContent.dn
@@ -0,0 +1,17 @@
+component provides App requires io.Output out, data.StringUtil stringUtil, data.IntUtil iu, os.Run run {
+	
+	int App:main(AppParam params[])
+		{
+		char filename[] = params[0].string
+		
+		String parts[] = stringUtil.explode(filename, ".")
+		
+		for (int i = 0; i < 20; i++)
+			{
+			run.execute("copy $filename $(parts[0].string)$(iu.intToString(i+1)).$(parts[1].string)")
+			}
+		
+		return 0
+		}
+	
+	}
\ No newline at end of file
diff --git a/src/cachingpolicy/htdocs/GenerateContent.o b/src/cachingpolicy/htdocs/GenerateContent.o
new file mode 100644
index 0000000..f735e6b
Binary files /dev/null and b/src/cachingpolicy/htdocs/GenerateContent.o differ
diff --git a/src/cachingpolicy/htdocs/Thumbs.db b/src/cachingpolicy/htdocs/Thumbs.db
new file mode 100644
index 0000000..24e74a0
Binary files /dev/null and b/src/cachingpolicy/htdocs/Thumbs.db differ
diff --git a/src/cachingpolicy/htdocs/image_big.jpg b/src/cachingpolicy/htdocs/image_big.jpg
new file mode 100644
index 0000000..5d48874
Binary files /dev/null and b/src/cachingpolicy/htdocs/image_big.jpg differ
diff --git a/src/cachingpolicy/htdocs/image_med.jpg b/src/cachingpolicy/htdocs/image_med.jpg
new file mode 100644
index 0000000..af36491
Binary files /dev/null and b/src/cachingpolicy/htdocs/image_med.jpg differ
diff --git a/src/cachingpolicy/htdocs/image_small.jpg b/src/cachingpolicy/htdocs/image_small.jpg
new file mode 100644
index 0000000..7add79c
Binary files /dev/null and b/src/cachingpolicy/htdocs/image_small.jpg differ
diff --git a/src/cachingpolicy/htdocs/index.html b/src/cachingpolicy/htdocs/index.html
new file mode 100644
index 0000000..ec25deb
--- /dev/null
+++ b/src/cachingpolicy/htdocs/index.html
@@ -0,0 +1,32 @@
+<html>
+
+<body>
+
+<p>
+	A text page. Here is some text:
+</p>
+
+<p>
+	But I couldn’t see it; my jumps didn’t take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+	Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+	Fourth and Fifth squads answered, "Wilco"; Ace said, "We’re already doin’ it — pick up your feet." Red’s beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+
+<p>
+	At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I’m no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn’t already been told to jump, I guess I wouldn’t have got out of there.
+</p>
+
+<p>
+	Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+</body>
+
+</html>
\ No newline at end of file
diff --git a/src/cachingpolicy/htdocs/index_150KB.html b/src/cachingpolicy/htdocs/index_150KB.html
new file mode 100644
index 0000000..0b1afae
--- /dev/null
+++ b/src/cachingpolicy/htdocs/index_150KB.html
@@ -0,0 +1,1282 @@
+<html>
+
+<body>
+
+<p>
+	A long text page. Here is some text:
+</p>
+
+<p>
+Then suddenly nothing. Nothing at all. No sound, no pressure, no weight. Floating in darkness... free fall, maybe thirty miles up, above the effective atmosphere, falling weightlessly toward the surface of a planet you've never seen. But I'm not shaking now; it's the wait beforehand that wears. Once you unload, you can't get hurt — because if anything goes wrong it will happen so fast that you'll buy it without noticing that you're dead, hardly.
+</p>
+
+<p>
+Almost at once I felt the capsule twist and sway, then steady down so that my weight was on my back...weight that built up quickly until I was at my full weight (0.87 gee, we had been told) for that planet as the capsule reached terminal velocity for the thin upper atmosphere. A pilot who is a real artist (and the Captain was) will approach and brake so that your launching speed as you shoot out of the tube places you just dead in space relative to the rotational speed of the planet at that latitude. The loaded capsules are heavy; they punch through the high, thin winds of the upper atmosphere without being blown too far out of position — but just the same a platoon is bound to disperse on the way down, lose some of the perfect formation in which it unloads. A sloppy pilot can make this still worse, scatter a strike group over so much terrain that it can't make rendezvous for retrieval, much less carry out its mission. An infantryman can fight only if somebody else delivers him to his zone; in a way I suppose pilots are just as essential as we are.
+</p>
+
+<p>
+I could tell from the gentle way my capsule entered the atmosphere that the Captain had laid us down with as near zero lateral vector as you could ask for. I felt happy — not only a tight formation when we hit and no time wasted, but also a pilot who puts you down properly is a pilot who is smart and precise on retrieval.
+</p>
+
+<p>
+The outer shell burned away and sloughed off — unevenly, for I tumbled. Then the rest of it went and I straightened out. The turbulence brakes of the second shell bit in and the ride got rough... and still rougher as they burned off one at a time and the second shell began to go to pieces. One of the things that helps a capsule trooper to live long enough to draw a pension is that the skins peeling off his capsule not only slow him down, they also fill the sky over the target area with so much junk that radar picks up reflections from dozens of targets for each man in the drop, any one of which could be a man, or a bomb, or anything. It's enough to give a ballistic computer nervous breakdowns — and does. To add to the fun your ship lays a series of dummy eggs in the seconds immediately following your drop, dummies that will fall faster because they don't slough. They get under you, explode, throw out "window," even operate as transponders, rocket sideways, and do other things to add to the confusion of your reception committee on the ground.
+</p>
+
+<p>
+In the meantime your ship is locked firmly on the directional beacon of your platoon leader, ignoring the radar "noise" it has created and following you in, computing your impact for future use. When the second shell was gone, the third shell automatically opened my first ribbon chute. It didn't last long but it wasn't expected to; one good, hard jerk at several gee and it went its way and I went mine. The second chute lasted a little bit longer and the third chute lasted quite a while; it began to be rather too warm inside the capsule and I started thinking about landing.
+</p>
+
+<p>
+The third shell peeled off when its last chute was gone and now I had nothing around me but my suit armor and a plastic egg. I was still strapped inside it, unable to move; it was time to decide how and where I was going to ground. Without moving my arms (I couldn't) I thumbed the switch for a proximity reading and read it when it flashed on in the instrument reflector inside my helmet in front of my forehead. A mile and eight-tenths — A little closer than I liked, especially without company. The inner egg had reached steady speed, no more help to be gained by staying inside it, and its skin temperature indicated that it would not open automatically for a while yet — so I flipped a switch with my other thumb and got rid of it.
+</p>
+
+<p>
+The first charge cut all the straps; the second charge exploded the plastic egg away from me in eight separate pieces — and I was outdoors, sitting on air, and could see! Better still, the eight discarded pieces were metal-coated (except for the small bit I had taken proximity reading through) and would give back the same reflection as an armored man. Any radar viewer, alive or cybernetic, would now have a sad time sorting me out from the junk nearest me, not to mention the thousands of other bits and pieces for miles on each side, above, and below me. Part of a mobile infantryman's training is to let him see, from the ground and both by eye and by radar, just how confusing a drop is to the forces on the ground — because you feel awful naked up there. It is easy to panic and either open a chute too soon and become a sitting duck (do ducks really sit? — if so, why?) or fail to open it and break your ankles, likewise backbone and skull. So I stretched, getting the kinks out, and looked around... then doubled up again and straightened out in a swan dive face down and took a good look. It was night down there, as planned, but infrared snoopers let you size up terrain quite well after you are used to them. The river that cut diagonally through the city was almost below me and coming up fast, shining out clearly with a higher temperature than the land. I didn't care which side of it I landed on but I didn't want to land in it; it would slow me down.
+</p>
+
+<p>
+I noticed a dash off to the right at about my altitude; some unfriendly native down below had burned what was probably a piece of my egg. So I fired my first chute at once, intending if possible to jerk myself right off his screen as he followed the targets down in closing range. I braced for the shock, rode it, then floated down for about twenty seconds before unloading the chute — not wishing to call attention to myself in still another way by not falling at the speed of the other stuff around me. It must have worked; I wasn't burned.
+</p>
+
+<p>
+About six hundred feet up I shot the second chute... saw very quickly that I was being carried over into the river, found that I was going to pass about a hundred feet up over a flat-roofed warehouse or some such by the river... blew the chute free and came in for a good enough if rather bouncy landing on the roof by means of the suit's jump jets. I was scanning for Sergeant Jelal's beacon as I hit. And found that I was on the wrong side of the river; Jelly's star showed up on the compass ring inside my helmet far south of where it should have been — I was too far north. I trotted toward the river side of the roof as I took a range and bearing on the squad leader next to me, found that he was over a mile out of position, called, "Ace! dress your line," tossed a bomb behind me as I stepped off the building and across the river. Ace answered as I could have expected — Ace should have had my spot but he didn't want to give up his squad; nevertheless he didn't fancy taking orders from me.
+</p>
+
+<p>
+The warehouse went up behind me and the blast hit me while I was still over the river, instead of being shielded by the buildings on the far side as I should have been. It darn near tumbled my gyros and I came close to tumbling myself. I had set that bomb for fifteen seconds... or had I? I suddenly realized that I had let myself get excited, the worst thing you can do once you're on the ground. "Just like a drill," that was the way, just as Jelly had warned me. Take your time and do it right, even if it takes another half second. As I hit I took another reading on Ace and told him again to realign his squad. He didn't answer but he was already doing it. I let it ride. As long as Ace did his job, I could afford to swallow his surliness — for now. But back aboard ship (if Jelly kept me on as assistant section leader) we would eventually have to pick a quiet spot and find out who was boss. He was a career corporal and I was just a term lance acting as corporal, but he was under me and you can't afford to take any lip under those circumstances. Not permanently.
+</p>
+
+<p>
+But I didn't have time then to think about it; while I was jumping the river I had spotted a juicy target and I wanted to get it before somebody else noticed it — a lovely big group of what looked like public buildings on a hill. Temples, maybe... or a palace. They were miles outside the area we were sweeping, but one rule of a smash & run is to expend at least half your ammo outside your sweep area; that way the enemy is kept confused as to where you actually are — that and keep moving, do everything fast. You're always heavily outnumbered; surprise and speed are what saves you. I was already loading my rocket launcher while I was checking on Ace and telling him for the second time to straighten up. Jelly's voice reached me right on top of that on the all-hands circuit: "Platoon! By leapfrog! Forward!" My boss, Sergeant Johnson, echoed, "By leapfrog! Odd numbers! Advance!" That left me with nothing to worry about for twenty seconds, so I jumped up on the building nearest me, raised the launcher to my shoulder, found the target and pulled the first trigger to let the rocket have a look at its target — pulled the second trigger and kissed it on its way, jumped back to the ground. "Second section, even numbers!" I called out... waited for the count in my mind and ordered, "Advance!"
+</p>
+
+<p>
+And did so myself, hopping over the next row of buildings, and, while I was in the air, fanning the first row by the river front with a hand flamer. They seemed to be wood construction and it looked like time to start a good fire — with luck, some of those warehouses would house oil products, or even explosives. As I hit, the Y-rack on my shoulders launched two small H. E. bombs a couple of hundred yards each way to my right and left flanks but I never saw what they did as just then my first rocket hit — that unmistakable (if you've ever seen one) brilliance of an atomic explosion. It was just a peewee, of course, less than two kilotons nominal yield, with tamper and implosion squeeze to produce results from a less-than-critical mass — but then who wants to be bunk mates with a cosmic catastrophe? It was enough to clean off that hilltop and make everybody in the city take shelter against fallout. Better still, any of the local yokels who happened to be outdoors and looking that way wouldn't be seeing anything else for a couple of hours — meaning me. The dash hadn't dazzled me, nor would it dazzle any of us; our face bowls are heavily leaded, we wear snoopers over our eyes — and we're trained to duck and take it on the armor if we do happen to be looking the wrong way.
+</p>
+
+<p>
+So I merely blinked hard — opened my eyes and stared straight at a local citizen just coming out of an opening in the building ahead of me. He looked at me, I looked at him, and he started to raise something — a weapon, I suppose — as Jelly called out, "Odd numbers! Advance!"
+</p>
+
+<p>
+I didn't have time to fool with him; I was a good five hundred yards short of where I should have been by then. I still had the hand flamer in my left hand; I toasted him and jumped over the building he had been coming out of, as I started to count. A hand flamer is primarily for incendiary work but it is a good defensive anti-personnel weapon in tight quarters; you don't have to aim it much.
+</p>
+
+<p>
+Between excitement and anxiety to catch up I jumped too high and too wide. It's always a temptation to get the most out of your jump gear — but don't do it! It leaves you hanging in the air for seconds, a big fat target. The way to advance is to skim over each building as you come to it, barely clearing it, and taking full advantage of cover while you're down — and never stay in one place more than a second or two, never give them time to target in on you. Be somewhere else, anywhere. Keep moving.
+</p>
+
+<p>
+</p>
+
+<p>This one I goofed — too much for one row of buildings, too little for the row beyond it; I found myself coming down on a roof. But not a nice flat one where I might have tarried three seconds to launch another peewee A-rocket; this roof was a jungle of pipes and stanchions and assorted ironmongery — a factory maybe, or some sort of chemical works. No place to land. Worse still, half a dozen natives were up there. These geezers are humanoid, eight or nine feet tall, much skinnier than we are and with a higher body temperature; they don't wear any clothes and they stand out in a set of snoopers like a neon sign. They look still funnier in daylight with your bare eyes but I would rather fight them than the arachnids — those Bugs make me queezy.
+</p>
+
+<p>
+If these laddies were up there thirty seconds earlier when my rocket hit, then they couldn't see me, or anything. But I couldn't be certain and didn't want to tangle with them in any case; it wasn't that kind of a raid. So I jumped again while I was still in the air, scattering a handful of ten-second fire pills to keep
+them busy, grounded, jumped again at once, and called out, "Second section! Even numbers!...Advance!" and kept right on going to close the gap, while trying to spot, every time I jumped, something worth expending a rocket on. I had three more of the little A-rockets and I certainly didn't intend to take any back with me.
+</p>
+
+<p>
+But I had had pounded into me that you must get your money's worth with atomic weapons — it was only the second time that I had been allowed to carry them. Right now I was trying to spot their waterworks; a direct hit on it could make the whole city uninhabitable, force them to evacuate it without directly killing anyone — just the sort of nuisance we had been sent down to commit. It should — according to the map we had studied under hypnosis — be about three miles upstream from where I was.
+</p>
+
+<p>
+But I couldn't see it; my jumps didn't take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+Fourth and Fifth squads answered, "Wilco"; Ace said, "We're already doin' it — pick up your feet." Red's beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+<p>
+At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I'm no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn't already been told to jump, I guess I wouldn't have got out of there.
+</p>
+
+<p>
+Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+<p>
+There was something on the horizon in the direction of their spaceport — administration & control, maybe, or possibly even a starship. Almost in line and about half as far away was an enormous structure which I couldn't identify even that loosely. The range to the spaceport was extreme but I let the rocket see it, said, "Go find it, baby!" and twisted its tail — slapped the last one in, sent it toward the nearer target, and jumped. That building took a direct hit just as I left it. Either a skinny had judged (correctly) that it was worth one of their buildings to try for one of us, or one of my own mates was getting mighty careless with fireworks. Either way, I didn't want to jump from that spot, even a skimmer; I decided to go through the next couple of buildings instead of over. So I grabbed the heavy flamer off my back as I hit and dipped the snoopers down over my eyes, tackled a wall in front of me with a knife beam at full power. A section of
+wall fell away and I charged in. And backed out even faster. I didn't know what it was I had cracked open. A congregation in church — a skinny flophouse —
+maybe even their defense headquarters. All I knew was that it was a very big room filled with more skinnies than I wanted to see in my whole life.
+</p>
+
+<p>
+Probably not a church, for somebody took a shot at me as I popped back out just a slug that bounced off my armor, made my ears ring, and staggered me without hurting me. But it reminded me that I wasn't supposed to leave without giving them a souvenir of my visit. I grabbed the first thing on my belt and lobbed it in — and heard it start to squawk. As they keep telling you in Basic, doing something constructive at once is better than figuring out the best thing to do hours later. By sheer chance I had done the right thing. This was a special bomb, one each issued to us for this mission with instructions to use them if we found ways to make them effective. The squawking I heard as I threw it was the bomb shouting in skinny talk (free translation): "I'm a thirty-second bomb! I'm a thirty-second bomb! Twenty-nine!... twenty-eight!... twenty-seven! — "It was supposed to frazzle their nerves. Maybe it did; it certainly frazzled mine. Kinder to shoot a man. I didn't wait for the countdown; I jumped, while I wondered whether they would find enough doors and windows to swarm out in time.
+</p>
+
+<p>
+I got a bearing on Red's blinker at the top of the jump and one on Ace as I grounded. I was falling behind again — time to hurry. But three minutes later we had closed the gap; I had Red on my left flank a half mile away. He reported it to Jelly. We heard Jelly's relaxed growl to the entire platoon: "Circle is closed, but the beacon is not down yet. Move forward slowly and mill around, make a little more trouble — but mind the lad on each side of you; don't make trouble for him. Good job, so far — don't spoil it. Platoon! By sections...Muster!"
+</p>
+
+<p>
+It looked like a good job to me, too; much of the city was burning and, although it was almost full light now, it was hard to tell whether bare eyes were better than snoopers, the smoke was so thick. Johnson, our section leader, sounded off: "Second section, call off!" I echoed, "Squads four, five, and six — call off and report!" The assortment of safe circuits we had available in the new model comm units certainly speeded things up; Jelly could talk to anybody or to his section leaders; a section leader could call his whole section, or his non-coms; and the platoon could muster twice as fast, when seconds matter. I listened to the fourth squad call off while I inventoried my remaining firepower and lobbed one bomb toward a skinny who poked his head around a corner. He left and so did I — "Mill around," the boss man had said.
+</p>
+
+<p>
+The fourth squad bumbled the call off until the squad leader remembered to fill in with Jenkins' number; the fifth squad clicked off like an abacus and I began to feel good . . . when the call off stopped after number four in Ace's squad. I called out, "Ace, where's Dizzy?"
+</p>
+
+<p>
+"Shut up," he said. "Number six! Call off!"
+</p>
+
+<p>
+"Six!" Smith answered.
+</p>
+
+<p>
+"Seven!"
+</p>
+
+<p>
+"Sixth squad, Flores missing," Ace completed it. "Squad leader out for pickup."
+</p>
+
+<p>
+"One man absent," I reported to Johnson. "Flores, squad six."
+</p>
+
+<p>
+"Missing or dead?"
+</p>
+
+<p>
+"I don't know. Squad leader and assistant section leader dropping out for pickup."
+</p>
+
+<p>
+"Johnnie, you let Ace take it."
+</p>
+
+<p>
+But I didn't hear him, so I didn't answer. I heard him report to Jelly and I heard Jelly cuss. Now look, I wasn't bucking for a medal — it's the assistant section leader's business to make pickup; he's the chaser, the last man in, expendable. The squad leaders have other work to do. As you've no doubt gathered by now the assistant section leader isn't necessary as long as the section leader is alive. Right that moment I was feeling unusually expendable, almost expended, because I was hearing the sweetest sound in the universe, the beacon the retrieval boat would land on, sounding our recall. The beacon is a robot rocket, fired ahead of the retrieval boat, just a spike that buries itself in the ground and starts broadcasting that welcome, welcome music. The retrieval boat homes in on it automatically three minutes later and you had better be on hand, because the bus can't wait and there won't be another one along.
+</p>
+
+<p>
+But you don't walk away on another cap trooper, not while there's a chance he's still alive — not in Rasczak's Roughnecks. Not in any outfit of the Mobile Infantry. You try to make pickup. I heard Jelly order: "Heads up, lads! Close to retrieval circle and interdict! On the bounce!"
+</p>
+
+<p>
+And I heard the beacon's sweet voice: " — to the everlasting glory of the infantry, shines the name, shines the name of Rodger Young!" and I wanted to head for it so bad I could taste it.
+</p>
+
+<p>
+Instead I was headed the other way, closing on Ace's beacon and expending what I had left of bombs and fire pills and anything else that would weigh me down. "Ace! You got his beacon?"
+</p>
+
+<p>
+"Yes. Go back, Useless!"
+</p>
+
+<p>
+"I've got you by eye now. Where is he?"
+</p>
+
+<p>
+"Right ahead of me, maybe quarter mile. Scram! He's my man ."
+</p>
+
+<p>
+I didn't answer; I simply cut left oblique to reach Ace about where he said Dizzy was.
+</p>
+
+<p>
+And found Ace standing over him, a couple of skinnies flamed down and more running away. I lit beside him. "Let's get him out of his armor — the boat'll be down any second!"
+</p>
+
+<p>
+"He's too bad hurt!"
+</p>
+
+<p>
+I looked and saw that it was true — there was actually a hole in his armor and blood coming out. And I was stumped. To make a wounded pickup you get him out of his armor... then you simply pick him up in your arms — no trouble in a powered suit — and bounce away from there. A bare man weighs less than the ammo and stuff you've expended. "What'll we do?"
+</p>
+
+<p>
+"We carry him," Ace said grimly. "Grab ahold the left side of his belt." He grabbed the right side, we manhandled Flores to his feet. "Lock on! Now... by the numbers, stand by to jump — one — two!"
+</p>
+
+<p>
+We jumped. Not far, not well. One man alone couldn't have gotten him off the ground; an armored suit is too heavy. But split it between two men and it can be done.
+We jumped — and we jumped — and again, and again, with Ace calling it and both of us steadying and catching Dizzy on each grounding. His gyros seemed to be out.
+</p>
+
+<p>
+We heard the beacon cut off as the retrieval boat landed on it — I saw it land . . . and it was too far away. We heard the acting platoon sergeant call out: "In succession, prepare to embark!"
+</p>
+
+<p>
+And Jelly called out, "Belay that order!"
+</p>
+
+<p>
+We broke at last into the open and saw the boat standing on its tail, heard the ululation of its take-off warning — saw the platoon still on the ground around it, in interdiction circle, crouching behind the shield they had formed. Heard Jelly shout, "In succession, man the boat — move!"
+</p>
+
+<p>
+And we were still too far away! I could see them peel off from the first squad, swarm into the boat as the interdiction circle tightened. And a single figure broke out of the circle, came toward us at a speed possible only to a command suit. Jelly caught us while we were in the air, grabbed Flores by his Y-rack and helped us lift. Three jumps got us to the boat. Everybody else was inside but the door was still open. We got him in and closed it while the boat pilot screamed that we had made her miss rendezvous and now we had all bought it! Jelly paid no attention to her; we laid Flores down and lay down beside him. As the blast hit us Jelly was saying to himself, "All present, Lieutenant. Three men hurt — but all present!"
+</p>
+
+<p>
+I'll say this for Captain Deladrier: they don't make any better pilots. A rendezvous, boat to ship in orbit, is precisely calculated. I don't know how, but it is, and you don't change it. You can't.
+</p>
+
+<p>
+Only she did. She saw in her scope that the boat had failed to blast on time; she braked back, picked up speed again — and matched and took us in, just by eye and touch, no time to compute it. If the Almighty ever needs an assistant to keep the stars in their courses, I know where he can look.
+</p>
+
+<p>
+Flores died on the way up.
+</p>
+
+<p>
+ -- repeat --
+</p>
+
+<p>
+Then suddenly nothing. Nothing at all. No sound, no pressure, no weight. Floating in darkness... free fall, maybe thirty miles up, above the effective atmosphere, falling weightlessly toward the surface of a planet you've never seen. But I'm not shaking now; it's the wait beforehand that wears. Once you unload, you can't get hurt — because if anything goes wrong it will happen so fast that you'll buy it without noticing that you're dead, hardly.
+</p>
+
+<p>
+Almost at once I felt the capsule twist and sway, then steady down so that my weight was on my back...weight that built up quickly until I was at my full weight (0.87 gee, we had been told) for that planet as the capsule reached terminal velocity for the thin upper atmosphere. A pilot who is a real artist (and the Captain was) will approach and brake so that your launching speed as you shoot out of the tube places you just dead in space relative to the rotational speed of the planet at that latitude. The loaded capsules are heavy; they punch through the high, thin winds of the upper atmosphere without being blown too far out of position — but just the same a platoon is bound to disperse on the way down, lose some of the perfect formation in which it unloads. A sloppy pilot can make this still worse, scatter a strike group over so much terrain that it can't make rendezvous for retrieval, much less carry out its mission. An infantryman can fight only if somebody else delivers him to his zone; in a way I suppose pilots are just as essential as we are.
+</p>
+
+<p>
+I could tell from the gentle way my capsule entered the atmosphere that the Captain had laid us down with as near zero lateral vector as you could ask for. I felt happy — not only a tight formation when we hit and no time wasted, but also a pilot who puts you down properly is a pilot who is smart and precise on retrieval.
+</p>
+
+<p>
+The outer shell burned away and sloughed off — unevenly, for I tumbled. Then the rest of it went and I straightened out. The turbulence brakes of the second shell bit in and the ride got rough... and still rougher as they burned off one at a time and the second shell began to go to pieces. One of the things that helps a capsule trooper to live long enough to draw a pension is that the skins peeling off his capsule not only slow him down, they also fill the sky over the target area with so much junk that radar picks up reflections from dozens of targets for each man in the drop, any one of which could be a man, or a bomb, or anything. It's enough to give a ballistic computer nervous breakdowns — and does. To add to the fun your ship lays a series of dummy eggs in the seconds immediately following your drop, dummies that will fall faster because they don't slough. They get under you, explode, throw out "window," even operate as transponders, rocket sideways, and do other things to add to the confusion of your reception committee on the ground.
+</p>
+
+<p>
+In the meantime your ship is locked firmly on the directional beacon of your platoon leader, ignoring the radar "noise" it has created and following you in, computing your impact for future use. When the second shell was gone, the third shell automatically opened my first ribbon chute. It didn't last long but it wasn't expected to; one good, hard jerk at several gee and it went its way and I went mine. The second chute lasted a little bit longer and the third chute lasted quite a while; it began to be rather too warm inside the capsule and I started thinking about landing.
+</p>
+
+<p>
+The third shell peeled off when its last chute was gone and now I had nothing around me but my suit armor and a plastic egg. I was still strapped inside it, unable to move; it was time to decide how and where I was going to ground. Without moving my arms (I couldn't) I thumbed the switch for a proximity reading and read it when it flashed on in the instrument reflector inside my helmet in front of my forehead. A mile and eight-tenths — A little closer than I liked, especially without company. The inner egg had reached steady speed, no more help to be gained by staying inside it, and its skin temperature indicated that it would not open automatically for a while yet — so I flipped a switch with my other thumb and got rid of it.
+</p>
+
+<p>
+The first charge cut all the straps; the second charge exploded the plastic egg away from me in eight separate pieces — and I was outdoors, sitting on air, and could see! Better still, the eight discarded pieces were metal-coated (except for the small bit I had taken proximity reading through) and would give back the same reflection as an armored man. Any radar viewer, alive or cybernetic, would now have a sad time sorting me out from the junk nearest me, not to mention the thousands of other bits and pieces for miles on each side, above, and below me. Part of a mobile infantryman's training is to let him see, from the ground and both by eye and by radar, just how confusing a drop is to the forces on the ground — because you feel awful naked up there. It is easy to panic and either open a chute too soon and become a sitting duck (do ducks really sit? — if so, why?) or fail to open it and break your ankles, likewise backbone and skull. So I stretched, getting the kinks out, and looked around... then doubled up again and straightened out in a swan dive face down and took a good look. It was night down there, as planned, but infrared snoopers let you size up terrain quite well after you are used to them. The river that cut diagonally through the city was almost below me and coming up fast, shining out clearly with a higher temperature than the land. I didn't care which side of it I landed on but I didn't want to land in it; it would slow me down.
+</p>
+
+<p>
+I noticed a dash off to the right at about my altitude; some unfriendly native down below had burned what was probably a piece of my egg. So I fired my first chute at once, intending if possible to jerk myself right off his screen as he followed the targets down in closing range. I braced for the shock, rode it, then floated down for about twenty seconds before unloading the chute — not wishing to call attention to myself in still another way by not falling at the speed of the other stuff around me. It must have worked; I wasn't burned.
+</p>
+
+<p>
+About six hundred feet up I shot the second chute... saw very quickly that I was being carried over into the river, found that I was going to pass about a hundred feet up over a flat-roofed warehouse or some such by the river... blew the chute free and came in for a good enough if rather bouncy landing on the roof by means of the suit's jump jets. I was scanning for Sergeant Jelal's beacon as I hit. And found that I was on the wrong side of the river; Jelly's star showed up on the compass ring inside my helmet far south of where it should have been — I was too far north. I trotted toward the river side of the roof as I took a range and bearing on the squad leader next to me, found that he was over a mile out of position, called, "Ace! dress your line," tossed a bomb behind me as I stepped off the building and across the river. Ace answered as I could have expected — Ace should have had my spot but he didn't want to give up his squad; nevertheless he didn't fancy taking orders from me.
+</p>
+
+<p>
+The warehouse went up behind me and the blast hit me while I was still over the river, instead of being shielded by the buildings on the far side as I should have been. It darn near tumbled my gyros and I came close to tumbling myself. I had set that bomb for fifteen seconds... or had I? I suddenly realized that I had let myself get excited, the worst thing you can do once you're on the ground. "Just like a drill," that was the way, just as Jelly had warned me. Take your time and do it right, even if it takes another half second. As I hit I took another reading on Ace and told him again to realign his squad. He didn't answer but he was already doing it. I let it ride. As long as Ace did his job, I could afford to swallow his surliness — for now. But back aboard ship (if Jelly kept me on as assistant section leader) we would eventually have to pick a quiet spot and find out who was boss. He was a career corporal and I was just a term lance acting as corporal, but he was under me and you can't afford to take any lip under those circumstances. Not permanently.
+</p>
+
+<p>
+But I didn't have time then to think about it; while I was jumping the river I had spotted a juicy target and I wanted to get it before somebody else noticed it — a lovely big group of what looked like public buildings on a hill. Temples, maybe... or a palace. They were miles outside the area we were sweeping, but one rule of a smash & run is to expend at least half your ammo outside your sweep area; that way the enemy is kept confused as to where you actually are — that and keep moving, do everything fast. You're always heavily outnumbered; surprise and speed are what saves you. I was already loading my rocket launcher while I was checking on Ace and telling him for the second time to straighten up. Jelly's voice reached me right on top of that on the all-hands circuit: "Platoon! By leapfrog! Forward!" My boss, Sergeant Johnson, echoed, "By leapfrog! Odd numbers! Advance!" That left me with nothing to worry about for twenty seconds, so I jumped up on the building nearest me, raised the launcher to my shoulder, found the target and pulled the first trigger to let the rocket have a look at its target — pulled the second trigger and kissed it on its way, jumped back to the ground. "Second section, even numbers!" I called out... waited for the count in my mind and ordered, "Advance!"
+</p>
+
+<p>
+And did so myself, hopping over the next row of buildings, and, while I was in the air, fanning the first row by the river front with a hand flamer. They seemed to be wood construction and it looked like time to start a good fire — with luck, some of those warehouses would house oil products, or even explosives. As I hit, the Y-rack on my shoulders launched two small H. E. bombs a couple of hundred yards each way to my right and left flanks but I never saw what they did as just then my first rocket hit — that unmistakable (if you've ever seen one) brilliance of an atomic explosion. It was just a peewee, of course, less than two kilotons nominal yield, with tamper and implosion squeeze to produce results from a less-than-critical mass — but then who wants to be bunk mates with a cosmic catastrophe? It was enough to clean off that hilltop and make everybody in the city take shelter against fallout. Better still, any of the local yokels who happened to be outdoors and looking that way wouldn't be seeing anything else for a couple of hours — meaning me. The dash hadn't dazzled me, nor would it dazzle any of us; our face bowls are heavily leaded, we wear snoopers over our eyes — and we're trained to duck and take it on the armor if we do happen to be looking the wrong way.
+</p>
+
+<p>
+So I merely blinked hard — opened my eyes and stared straight at a local citizen just coming out of an opening in the building ahead of me. He looked at me, I looked at him, and he started to raise something — a weapon, I suppose — as Jelly called out, "Odd numbers! Advance!"
+</p>
+
+<p>
+I didn't have time to fool with him; I was a good five hundred yards short of where I should have been by then. I still had the hand flamer in my left hand; I toasted him and jumped over the building he had been coming out of, as I started to count. A hand flamer is primarily for incendiary work but it is a good defensive anti-personnel weapon in tight quarters; you don't have to aim it much.
+</p>
+
+<p>
+Between excitement and anxiety to catch up I jumped too high and too wide. It's always a temptation to get the most out of your jump gear — but don't do it! It leaves you hanging in the air for seconds, a big fat target. The way to advance is to skim over each building as you come to it, barely clearing it, and taking full advantage of cover while you're down — and never stay in one place more than a second or two, never give them time to target in on you. Be somewhere else, anywhere. Keep moving.
+</p>
+
+<p>
+</p>
+
+<p>This one I goofed — too much for one row of buildings, too little for the row beyond it; I found myself coming down on a roof. But not a nice flat one where I might have tarried three seconds to launch another peewee A-rocket; this roof was a jungle of pipes and stanchions and assorted ironmongery — a factory maybe, or some sort of chemical works. No place to land. Worse still, half a dozen natives were up there. These geezers are humanoid, eight or nine feet tall, much skinnier than we are and with a higher body temperature; they don't wear any clothes and they stand out in a set of snoopers like a neon sign. They look still funnier in daylight with your bare eyes but I would rather fight them than the arachnids — those Bugs make me queezy.
+</p>
+
+<p>
+If these laddies were up there thirty seconds earlier when my rocket hit, then they couldn't see me, or anything. But I couldn't be certain and didn't want to tangle with them in any case; it wasn't that kind of a raid. So I jumped again while I was still in the air, scattering a handful of ten-second fire pills to keep
+them busy, grounded, jumped again at once, and called out, "Second section! Even numbers!...Advance!" and kept right on going to close the gap, while trying to spot, every time I jumped, something worth expending a rocket on. I had three more of the little A-rockets and I certainly didn't intend to take any back with me.
+</p>
+
+<p>
+But I had had pounded into me that you must get your money's worth with atomic weapons — it was only the second time that I had been allowed to carry them. Right now I was trying to spot their waterworks; a direct hit on it could make the whole city uninhabitable, force them to evacuate it without directly killing anyone — just the sort of nuisance we had been sent down to commit. It should — according to the map we had studied under hypnosis — be about three miles upstream from where I was.
+</p>
+
+<p>
+But I couldn't see it; my jumps didn't take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+Fourth and Fifth squads answered, "Wilco"; Ace said, "We're already doin' it — pick up your feet." Red's beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+<p>
+At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I'm no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn't already been told to jump, I guess I wouldn't have got out of there.
+</p>
+
+<p>
+Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+<p>
+There was something on the horizon in the direction of their spaceport — administration & control, maybe, or possibly even a starship. Almost in line and about half as far away was an enormous structure which I couldn't identify even that loosely. The range to the spaceport was extreme but I let the rocket see it, said, "Go find it, baby!" and twisted its tail — slapped the last one in, sent it toward the nearer target, and jumped. That building took a direct hit just as I left it. Either a skinny had judged (correctly) that it was worth one of their buildings to try for one of us, or one of my own mates was getting mighty careless with fireworks. Either way, I didn't want to jump from that spot, even a skimmer; I decided to go through the next couple of buildings instead of over. So I grabbed the heavy flamer off my back as I hit and dipped the snoopers down over my eyes, tackled a wall in front of me with a knife beam at full power. A section of
+wall fell away and I charged in. And backed out even faster. I didn't know what it was I had cracked open. A congregation in church — a skinny flophouse —
+maybe even their defense headquarters. All I knew was that it was a very big room filled with more skinnies than I wanted to see in my whole life.
+</p>
+
+<p>
+Probably not a church, for somebody took a shot at me as I popped back out just a slug that bounced off my armor, made my ears ring, and staggered me without hurting me. But it reminded me that I wasn't supposed to leave without giving them a souvenir of my visit. I grabbed the first thing on my belt and lobbed it in — and heard it start to squawk. As they keep telling you in Basic, doing something constructive at once is better than figuring out the best thing to do hours later. By sheer chance I had done the right thing. This was a special bomb, one each issued to us for this mission with instructions to use them if we found ways to make them effective. The squawking I heard as I threw it was the bomb shouting in skinny talk (free translation): "I'm a thirty-second bomb! I'm a thirty-second bomb! Twenty-nine!... twenty-eight!... twenty-seven! — "It was supposed to frazzle their nerves. Maybe it did; it certainly frazzled mine. Kinder to shoot a man. I didn't wait for the countdown; I jumped, while I wondered whether they would find enough doors and windows to swarm out in time.
+</p>
+
+<p>
+I got a bearing on Red's blinker at the top of the jump and one on Ace as I grounded. I was falling behind again — time to hurry. But three minutes later we had closed the gap; I had Red on my left flank a half mile away. He reported it to Jelly. We heard Jelly's relaxed growl to the entire platoon: "Circle is closed, but the beacon is not down yet. Move forward slowly and mill around, make a little more trouble — but mind the lad on each side of you; don't make trouble for him. Good job, so far — don't spoil it. Platoon! By sections...Muster!"
+</p>
+
+<p>
+It looked like a good job to me, too; much of the city was burning and, although it was almost full light now, it was hard to tell whether bare eyes were better than snoopers, the smoke was so thick. Johnson, our section leader, sounded off: "Second section, call off!" I echoed, "Squads four, five, and six — call off and report!" The assortment of safe circuits we had available in the new model comm units certainly speeded things up; Jelly could talk to anybody or to his section leaders; a section leader could call his whole section, or his non-coms; and the platoon could muster twice as fast, when seconds matter. I listened to the fourth squad call off while I inventoried my remaining firepower and lobbed one bomb toward a skinny who poked his head around a corner. He left and so did I — "Mill around," the boss man had said.
+</p>
+
+<p>
+The fourth squad bumbled the call off until the squad leader remembered to fill in with Jenkins' number; the fifth squad clicked off like an abacus and I began to feel good . . . when the call off stopped after number four in Ace's squad. I called out, "Ace, where's Dizzy?"
+</p>
+
+<p>
+"Shut up," he said. "Number six! Call off!"
+</p>
+
+<p>
+"Six!" Smith answered.
+</p>
+
+<p>
+"Seven!"
+</p>
+
+<p>
+"Sixth squad, Flores missing," Ace completed it. "Squad leader out for pickup."
+</p>
+
+<p>
+"One man absent," I reported to Johnson. "Flores, squad six."
+</p>
+
+<p>
+"Missing or dead?"
+</p>
+
+<p>
+"I don't know. Squad leader and assistant section leader dropping out for pickup."
+</p>
+
+<p>
+"Johnnie, you let Ace take it."
+</p>
+
+<p>
+But I didn't hear him, so I didn't answer. I heard him report to Jelly and I heard Jelly cuss. Now look, I wasn't bucking for a medal — it's the assistant section leader's business to make pickup; he's the chaser, the last man in, expendable. The squad leaders have other work to do. As you've no doubt gathered by now the assistant section leader isn't necessary as long as the section leader is alive. Right that moment I was feeling unusually expendable, almost expended, because I was hearing the sweetest sound in the universe, the beacon the retrieval boat would land on, sounding our recall. The beacon is a robot rocket, fired ahead of the retrieval boat, just a spike that buries itself in the ground and starts broadcasting that welcome, welcome music. The retrieval boat homes in on it automatically three minutes later and you had better be on hand, because the bus can't wait and there won't be another one along.
+</p>
+
+<p>
+But you don't walk away on another cap trooper, not while there's a chance he's still alive — not in Rasczak's Roughnecks. Not in any outfit of the Mobile Infantry. You try to make pickup. I heard Jelly order: "Heads up, lads! Close to retrieval circle and interdict! On the bounce!"
+</p>
+
+<p>
+And I heard the beacon's sweet voice: " — to the everlasting glory of the infantry, shines the name, shines the name of Rodger Young!" and I wanted to head for it so bad I could taste it.
+</p>
+
+<p>
+Instead I was headed the other way, closing on Ace's beacon and expending what I had left of bombs and fire pills and anything else that would weigh me down. "Ace! You got his beacon?"
+</p>
+
+<p>
+"Yes. Go back, Useless!"
+</p>
+
+<p>
+"I've got you by eye now. Where is he?"
+</p>
+
+<p>
+"Right ahead of me, maybe quarter mile. Scram! He's my man ."
+</p>
+
+<p>
+I didn't answer; I simply cut left oblique to reach Ace about where he said Dizzy was.
+</p>
+
+<p>
+And found Ace standing over him, a couple of skinnies flamed down and more running away. I lit beside him. "Let's get him out of his armor — the boat'll be down any second!"
+</p>
+
+<p>
+"He's too bad hurt!"
+</p>
+
+<p>
+I looked and saw that it was true — there was actually a hole in his armor and blood coming out. And I was stumped. To make a wounded pickup you get him out of his armor... then you simply pick him up in your arms — no trouble in a powered suit — and bounce away from there. A bare man weighs less than the ammo and stuff you've expended. "What'll we do?"
+</p>
+
+<p>
+"We carry him," Ace said grimly. "Grab ahold the left side of his belt." He grabbed the right side, we manhandled Flores to his feet. "Lock on! Now... by the numbers, stand by to jump — one — two!"
+</p>
+
+<p>
+We jumped. Not far, not well. One man alone couldn't have gotten him off the ground; an armored suit is too heavy. But split it between two men and it can be done.
+We jumped — and we jumped — and again, and again, with Ace calling it and both of us steadying and catching Dizzy on each grounding. His gyros seemed to be out.
+</p>
+
+<p>
+We heard the beacon cut off as the retrieval boat landed on it — I saw it land . . . and it was too far away. We heard the acting platoon sergeant call out: "In succession, prepare to embark!"
+</p>
+
+<p>
+And Jelly called out, "Belay that order!"
+</p>
+
+<p>
+We broke at last into the open and saw the boat standing on its tail, heard the ululation of its take-off warning — saw the platoon still on the ground around it, in interdiction circle, crouching behind the shield they had formed. Heard Jelly shout, "In succession, man the boat — move!"
+</p>
+
+<p>
+And we were still too far away! I could see them peel off from the first squad, swarm into the boat as the interdiction circle tightened. And a single figure broke out of the circle, came toward us at a speed possible only to a command suit. Jelly caught us while we were in the air, grabbed Flores by his Y-rack and helped us lift. Three jumps got us to the boat. Everybody else was inside but the door was still open. We got him in and closed it while the boat pilot screamed that we had made her miss rendezvous and now we had all bought it! Jelly paid no attention to her; we laid Flores down and lay down beside him. As the blast hit us Jelly was saying to himself, "All present, Lieutenant. Three men hurt — but all present!"
+</p>
+
+<p>
+I'll say this for Captain Deladrier: they don't make any better pilots. A rendezvous, boat to ship in orbit, is precisely calculated. I don't know how, but it is, and you don't change it. You can't.
+</p>
+
+<p>
+Only she did. She saw in her scope that the boat had failed to blast on time; she braked back, picked up speed again — and matched and took us in, just by eye and touch, no time to compute it. If the Almighty ever needs an assistant to keep the stars in their courses, I know where he can look.
+</p>
+
+<p>
+Flores died on the way up.
+</p>
+
+<p>
+ -- repeat --
+</p>
+
+<p>
+Then suddenly nothing. Nothing at all. No sound, no pressure, no weight. Floating in darkness... free fall, maybe thirty miles up, above the effective atmosphere, falling weightlessly toward the surface of a planet you've never seen. But I'm not shaking now; it's the wait beforehand that wears. Once you unload, you can't get hurt — because if anything goes wrong it will happen so fast that you'll buy it without noticing that you're dead, hardly.
+</p>
+
+<p>
+Almost at once I felt the capsule twist and sway, then steady down so that my weight was on my back...weight that built up quickly until I was at my full weight (0.87 gee, we had been told) for that planet as the capsule reached terminal velocity for the thin upper atmosphere. A pilot who is a real artist (and the Captain was) will approach and brake so that your launching speed as you shoot out of the tube places you just dead in space relative to the rotational speed of the planet at that latitude. The loaded capsules are heavy; they punch through the high, thin winds of the upper atmosphere without being blown too far out of position — but just the same a platoon is bound to disperse on the way down, lose some of the perfect formation in which it unloads. A sloppy pilot can make this still worse, scatter a strike group over so much terrain that it can't make rendezvous for retrieval, much less carry out its mission. An infantryman can fight only if somebody else delivers him to his zone; in a way I suppose pilots are just as essential as we are.
+</p>
+
+<p>
+I could tell from the gentle way my capsule entered the atmosphere that the Captain had laid us down with as near zero lateral vector as you could ask for. I felt happy — not only a tight formation when we hit and no time wasted, but also a pilot who puts you down properly is a pilot who is smart and precise on retrieval.
+</p>
+
+<p>
+The outer shell burned away and sloughed off — unevenly, for I tumbled. Then the rest of it went and I straightened out. The turbulence brakes of the second shell bit in and the ride got rough... and still rougher as they burned off one at a time and the second shell began to go to pieces. One of the things that helps a capsule trooper to live long enough to draw a pension is that the skins peeling off his capsule not only slow him down, they also fill the sky over the target area with so much junk that radar picks up reflections from dozens of targets for each man in the drop, any one of which could be a man, or a bomb, or anything. It's enough to give a ballistic computer nervous breakdowns — and does. To add to the fun your ship lays a series of dummy eggs in the seconds immediately following your drop, dummies that will fall faster because they don't slough. They get under you, explode, throw out "window," even operate as transponders, rocket sideways, and do other things to add to the confusion of your reception committee on the ground.
+</p>
+
+<p>
+In the meantime your ship is locked firmly on the directional beacon of your platoon leader, ignoring the radar "noise" it has created and following you in, computing your impact for future use. When the second shell was gone, the third shell automatically opened my first ribbon chute. It didn't last long but it wasn't expected to; one good, hard jerk at several gee and it went its way and I went mine. The second chute lasted a little bit longer and the third chute lasted quite a while; it began to be rather too warm inside the capsule and I started thinking about landing.
+</p>
+
+<p>
+The third shell peeled off when its last chute was gone and now I had nothing around me but my suit armor and a plastic egg. I was still strapped inside it, unable to move; it was time to decide how and where I was going to ground. Without moving my arms (I couldn't) I thumbed the switch for a proximity reading and read it when it flashed on in the instrument reflector inside my helmet in front of my forehead. A mile and eight-tenths — A little closer than I liked, especially without company. The inner egg had reached steady speed, no more help to be gained by staying inside it, and its skin temperature indicated that it would not open automatically for a while yet — so I flipped a switch with my other thumb and got rid of it.
+</p>
+
+<p>
+The first charge cut all the straps; the second charge exploded the plastic egg away from me in eight separate pieces — and I was outdoors, sitting on air, and could see! Better still, the eight discarded pieces were metal-coated (except for the small bit I had taken proximity reading through) and would give back the same reflection as an armored man. Any radar viewer, alive or cybernetic, would now have a sad time sorting me out from the junk nearest me, not to mention the thousands of other bits and pieces for miles on each side, above, and below me. Part of a mobile infantryman's training is to let him see, from the ground and both by eye and by radar, just how confusing a drop is to the forces on the ground — because you feel awful naked up there. It is easy to panic and either open a chute too soon and become a sitting duck (do ducks really sit? — if so, why?) or fail to open it and break your ankles, likewise backbone and skull. So I stretched, getting the kinks out, and looked around... then doubled up again and straightened out in a swan dive face down and took a good look. It was night down there, as planned, but infrared snoopers let you size up terrain quite well after you are used to them. The river that cut diagonally through the city was almost below me and coming up fast, shining out clearly with a higher temperature than the land. I didn't care which side of it I landed on but I didn't want to land in it; it would slow me down.
+</p>
+
+<p>
+I noticed a dash off to the right at about my altitude; some unfriendly native down below had burned what was probably a piece of my egg. So I fired my first chute at once, intending if possible to jerk myself right off his screen as he followed the targets down in closing range. I braced for the shock, rode it, then floated down for about twenty seconds before unloading the chute — not wishing to call attention to myself in still another way by not falling at the speed of the other stuff around me. It must have worked; I wasn't burned.
+</p>
+
+<p>
+About six hundred feet up I shot the second chute... saw very quickly that I was being carried over into the river, found that I was going to pass about a hundred feet up over a flat-roofed warehouse or some such by the river... blew the chute free and came in for a good enough if rather bouncy landing on the roof by means of the suit's jump jets. I was scanning for Sergeant Jelal's beacon as I hit. And found that I was on the wrong side of the river; Jelly's star showed up on the compass ring inside my helmet far south of where it should have been — I was too far north. I trotted toward the river side of the roof as I took a range and bearing on the squad leader next to me, found that he was over a mile out of position, called, "Ace! dress your line," tossed a bomb behind me as I stepped off the building and across the river. Ace answered as I could have expected — Ace should have had my spot but he didn't want to give up his squad; nevertheless he didn't fancy taking orders from me.
+</p>
+
+<p>
+The warehouse went up behind me and the blast hit me while I was still over the river, instead of being shielded by the buildings on the far side as I should have been. It darn near tumbled my gyros and I came close to tumbling myself. I had set that bomb for fifteen seconds... or had I? I suddenly realized that I had let myself get excited, the worst thing you can do once you're on the ground. "Just like a drill," that was the way, just as Jelly had warned me. Take your time and do it right, even if it takes another half second. As I hit I took another reading on Ace and told him again to realign his squad. He didn't answer but he was already doing it. I let it ride. As long as Ace did his job, I could afford to swallow his surliness — for now. But back aboard ship (if Jelly kept me on as assistant section leader) we would eventually have to pick a quiet spot and find out who was boss. He was a career corporal and I was just a term lance acting as corporal, but he was under me and you can't afford to take any lip under those circumstances. Not permanently.
+</p>
+
+<p>
+But I didn't have time then to think about it; while I was jumping the river I had spotted a juicy target and I wanted to get it before somebody else noticed it — a lovely big group of what looked like public buildings on a hill. Temples, maybe... or a palace. They were miles outside the area we were sweeping, but one rule of a smash & run is to expend at least half your ammo outside your sweep area; that way the enemy is kept confused as to where you actually are — that and keep moving, do everything fast. You're always heavily outnumbered; surprise and speed are what saves you. I was already loading my rocket launcher while I was checking on Ace and telling him for the second time to straighten up. Jelly's voice reached me right on top of that on the all-hands circuit: "Platoon! By leapfrog! Forward!" My boss, Sergeant Johnson, echoed, "By leapfrog! Odd numbers! Advance!" That left me with nothing to worry about for twenty seconds, so I jumped up on the building nearest me, raised the launcher to my shoulder, found the target and pulled the first trigger to let the rocket have a look at its target — pulled the second trigger and kissed it on its way, jumped back to the ground. "Second section, even numbers!" I called out... waited for the count in my mind and ordered, "Advance!"
+</p>
+
+<p>
+And did so myself, hopping over the next row of buildings, and, while I was in the air, fanning the first row by the river front with a hand flamer. They seemed to be wood construction and it looked like time to start a good fire — with luck, some of those warehouses would house oil products, or even explosives. As I hit, the Y-rack on my shoulders launched two small H. E. bombs a couple of hundred yards each way to my right and left flanks but I never saw what they did as just then my first rocket hit — that unmistakable (if you've ever seen one) brilliance of an atomic explosion. It was just a peewee, of course, less than two kilotons nominal yield, with tamper and implosion squeeze to produce results from a less-than-critical mass — but then who wants to be bunk mates with a cosmic catastrophe? It was enough to clean off that hilltop and make everybody in the city take shelter against fallout. Better still, any of the local yokels who happened to be outdoors and looking that way wouldn't be seeing anything else for a couple of hours — meaning me. The dash hadn't dazzled me, nor would it dazzle any of us; our face bowls are heavily leaded, we wear snoopers over our eyes — and we're trained to duck and take it on the armor if we do happen to be looking the wrong way.
+</p>
+
+<p>
+So I merely blinked hard — opened my eyes and stared straight at a local citizen just coming out of an opening in the building ahead of me. He looked at me, I looked at him, and he started to raise something — a weapon, I suppose — as Jelly called out, "Odd numbers! Advance!"
+</p>
+
+<p>
+I didn't have time to fool with him; I was a good five hundred yards short of where I should have been by then. I still had the hand flamer in my left hand; I toasted him and jumped over the building he had been coming out of, as I started to count. A hand flamer is primarily for incendiary work but it is a good defensive anti-personnel weapon in tight quarters; you don't have to aim it much.
+</p>
+
+<p>
+Between excitement and anxiety to catch up I jumped too high and too wide. It's always a temptation to get the most out of your jump gear — but don't do it! It leaves you hanging in the air for seconds, a big fat target. The way to advance is to skim over each building as you come to it, barely clearing it, and taking full advantage of cover while you're down — and never stay in one place more than a second or two, never give them time to target in on you. Be somewhere else, anywhere. Keep moving.
+</p>
+
+<p>
+</p>
+
+<p>This one I goofed — too much for one row of buildings, too little for the row beyond it; I found myself coming down on a roof. But not a nice flat one where I might have tarried three seconds to launch another peewee A-rocket; this roof was a jungle of pipes and stanchions and assorted ironmongery — a factory maybe, or some sort of chemical works. No place to land. Worse still, half a dozen natives were up there. These geezers are humanoid, eight or nine feet tall, much skinnier than we are and with a higher body temperature; they don't wear any clothes and they stand out in a set of snoopers like a neon sign. They look still funnier in daylight with your bare eyes but I would rather fight them than the arachnids — those Bugs make me queezy.
+</p>
+
+<p>
+If these laddies were up there thirty seconds earlier when my rocket hit, then they couldn't see me, or anything. But I couldn't be certain and didn't want to tangle with them in any case; it wasn't that kind of a raid. So I jumped again while I was still in the air, scattering a handful of ten-second fire pills to keep
+them busy, grounded, jumped again at once, and called out, "Second section! Even numbers!...Advance!" and kept right on going to close the gap, while trying to spot, every time I jumped, something worth expending a rocket on. I had three more of the little A-rockets and I certainly didn't intend to take any back with me.
+</p>
+
+<p>
+But I had had pounded into me that you must get your money's worth with atomic weapons — it was only the second time that I had been allowed to carry them. Right now I was trying to spot their waterworks; a direct hit on it could make the whole city uninhabitable, force them to evacuate it without directly killing anyone — just the sort of nuisance we had been sent down to commit. It should — according to the map we had studied under hypnosis — be about three miles upstream from where I was.
+</p>
+
+<p>
+But I couldn't see it; my jumps didn't take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+Fourth and Fifth squads answered, "Wilco"; Ace said, "We're already doin' it — pick up your feet." Red's beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+<p>
+At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I'm no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn't already been told to jump, I guess I wouldn't have got out of there.
+</p>
+
+<p>
+Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+<p>
+There was something on the horizon in the direction of their spaceport — administration & control, maybe, or possibly even a starship. Almost in line and about half as far away was an enormous structure which I couldn't identify even that loosely. The range to the spaceport was extreme but I let the rocket see it, said, "Go find it, baby!" and twisted its tail — slapped the last one in, sent it toward the nearer target, and jumped. That building took a direct hit just as I left it. Either a skinny had judged (correctly) that it was worth one of their buildings to try for one of us, or one of my own mates was getting mighty careless with fireworks. Either way, I didn't want to jump from that spot, even a skimmer; I decided to go through the next couple of buildings instead of over. So I grabbed the heavy flamer off my back as I hit and dipped the snoopers down over my eyes, tackled a wall in front of me with a knife beam at full power. A section of
+wall fell away and I charged in. And backed out even faster. I didn't know what it was I had cracked open. A congregation in church — a skinny flophouse —
+maybe even their defense headquarters. All I knew was that it was a very big room filled with more skinnies than I wanted to see in my whole life.
+</p>
+
+<p>
+Probably not a church, for somebody took a shot at me as I popped back out just a slug that bounced off my armor, made my ears ring, and staggered me without hurting me. But it reminded me that I wasn't supposed to leave without giving them a souvenir of my visit. I grabbed the first thing on my belt and lobbed it in — and heard it start to squawk. As they keep telling you in Basic, doing something constructive at once is better than figuring out the best thing to do hours later. By sheer chance I had done the right thing. This was a special bomb, one each issued to us for this mission with instructions to use them if we found ways to make them effective. The squawking I heard as I threw it was the bomb shouting in skinny talk (free translation): "I'm a thirty-second bomb! I'm a thirty-second bomb! Twenty-nine!... twenty-eight!... twenty-seven! — "It was supposed to frazzle their nerves. Maybe it did; it certainly frazzled mine. Kinder to shoot a man. I didn't wait for the countdown; I jumped, while I wondered whether they would find enough doors and windows to swarm out in time.
+</p>
+
+<p>
+I got a bearing on Red's blinker at the top of the jump and one on Ace as I grounded. I was falling behind again — time to hurry. But three minutes later we had closed the gap; I had Red on my left flank a half mile away. He reported it to Jelly. We heard Jelly's relaxed growl to the entire platoon: "Circle is closed, but the beacon is not down yet. Move forward slowly and mill around, make a little more trouble — but mind the lad on each side of you; don't make trouble for him. Good job, so far — don't spoil it. Platoon! By sections...Muster!"
+</p>
+
+<p>
+It looked like a good job to me, too; much of the city was burning and, although it was almost full light now, it was hard to tell whether bare eyes were better than snoopers, the smoke was so thick. Johnson, our section leader, sounded off: "Second section, call off!" I echoed, "Squads four, five, and six — call off and report!" The assortment of safe circuits we had available in the new model comm units certainly speeded things up; Jelly could talk to anybody or to his section leaders; a section leader could call his whole section, or his non-coms; and the platoon could muster twice as fast, when seconds matter. I listened to the fourth squad call off while I inventoried my remaining firepower and lobbed one bomb toward a skinny who poked his head around a corner. He left and so did I — "Mill around," the boss man had said.
+</p>
+
+<p>
+The fourth squad bumbled the call off until the squad leader remembered to fill in with Jenkins' number; the fifth squad clicked off like an abacus and I began to feel good . . . when the call off stopped after number four in Ace's squad. I called out, "Ace, where's Dizzy?"
+</p>
+
+<p>
+"Shut up," he said. "Number six! Call off!"
+</p>
+
+<p>
+"Six!" Smith answered.
+</p>
+
+<p>
+"Seven!"
+</p>
+
+<p>
+"Sixth squad, Flores missing," Ace completed it. "Squad leader out for pickup."
+</p>
+
+<p>
+"One man absent," I reported to Johnson. "Flores, squad six."
+</p>
+
+<p>
+"Missing or dead?"
+</p>
+
+<p>
+"I don't know. Squad leader and assistant section leader dropping out for pickup."
+</p>
+
+<p>
+"Johnnie, you let Ace take it."
+</p>
+
+<p>
+But I didn't hear him, so I didn't answer. I heard him report to Jelly and I heard Jelly cuss. Now look, I wasn't bucking for a medal — it's the assistant section leader's business to make pickup; he's the chaser, the last man in, expendable. The squad leaders have other work to do. As you've no doubt gathered by now the assistant section leader isn't necessary as long as the section leader is alive. Right that moment I was feeling unusually expendable, almost expended, because I was hearing the sweetest sound in the universe, the beacon the retrieval boat would land on, sounding our recall. The beacon is a robot rocket, fired ahead of the retrieval boat, just a spike that buries itself in the ground and starts broadcasting that welcome, welcome music. The retrieval boat homes in on it automatically three minutes later and you had better be on hand, because the bus can't wait and there won't be another one along.
+</p>
+
+<p>
+But you don't walk away on another cap trooper, not while there's a chance he's still alive — not in Rasczak's Roughnecks. Not in any outfit of the Mobile Infantry. You try to make pickup. I heard Jelly order: "Heads up, lads! Close to retrieval circle and interdict! On the bounce!"
+</p>
+
+<p>
+And I heard the beacon's sweet voice: " — to the everlasting glory of the infantry, shines the name, shines the name of Rodger Young!" and I wanted to head for it so bad I could taste it.
+</p>
+
+<p>
+Instead I was headed the other way, closing on Ace's beacon and expending what I had left of bombs and fire pills and anything else that would weigh me down. "Ace! You got his beacon?"
+</p>
+
+<p>
+"Yes. Go back, Useless!"
+</p>
+
+<p>
+"I've got you by eye now. Where is he?"
+</p>
+
+<p>
+"Right ahead of me, maybe quarter mile. Scram! He's my man ."
+</p>
+
+<p>
+I didn't answer; I simply cut left oblique to reach Ace about where he said Dizzy was.
+</p>
+
+<p>
+And found Ace standing over him, a couple of skinnies flamed down and more running away. I lit beside him. "Let's get him out of his armor — the boat'll be down any second!"
+</p>
+
+<p>
+"He's too bad hurt!"
+</p>
+
+<p>
+I looked and saw that it was true — there was actually a hole in his armor and blood coming out. And I was stumped. To make a wounded pickup you get him out of his armor... then you simply pick him up in your arms — no trouble in a powered suit — and bounce away from there. A bare man weighs less than the ammo and stuff you've expended. "What'll we do?"
+</p>
+
+<p>
+"We carry him," Ace said grimly. "Grab ahold the left side of his belt." He grabbed the right side, we manhandled Flores to his feet. "Lock on! Now... by the numbers, stand by to jump — one — two!"
+</p>
+
+<p>
+We jumped. Not far, not well. One man alone couldn't have gotten him off the ground; an armored suit is too heavy. But split it between two men and it can be done.
+We jumped — and we jumped — and again, and again, with Ace calling it and both of us steadying and catching Dizzy on each grounding. His gyros seemed to be out.
+</p>
+
+<p>
+We heard the beacon cut off as the retrieval boat landed on it — I saw it land . . . and it was too far away. We heard the acting platoon sergeant call out: "In succession, prepare to embark!"
+</p>
+
+<p>
+And Jelly called out, "Belay that order!"
+</p>
+
+<p>
+We broke at last into the open and saw the boat standing on its tail, heard the ululation of its take-off warning — saw the platoon still on the ground around it, in interdiction circle, crouching behind the shield they had formed. Heard Jelly shout, "In succession, man the boat — move!"
+</p>
+
+<p>
+And we were still too far away! I could see them peel off from the first squad, swarm into the boat as the interdiction circle tightened. And a single figure broke out of the circle, came toward us at a speed possible only to a command suit. Jelly caught us while we were in the air, grabbed Flores by his Y-rack and helped us lift. Three jumps got us to the boat. Everybody else was inside but the door was still open. We got him in and closed it while the boat pilot screamed that we had made her miss rendezvous and now we had all bought it! Jelly paid no attention to her; we laid Flores down and lay down beside him. As the blast hit us Jelly was saying to himself, "All present, Lieutenant. Three men hurt — but all present!"
+</p>
+
+<p>
+I'll say this for Captain Deladrier: they don't make any better pilots. A rendezvous, boat to ship in orbit, is precisely calculated. I don't know how, but it is, and you don't change it. You can't.
+</p>
+
+<p>
+Only she did. She saw in her scope that the boat had failed to blast on time; she braked back, picked up speed again — and matched and took us in, just by eye and touch, no time to compute it. If the Almighty ever needs an assistant to keep the stars in their courses, I know where he can look.
+</p>
+
+<p>
+Flores died on the way up.
+</p>
+
+<p>
+ -- repeat --
+</p>
+
+<p>
+Then suddenly nothing. Nothing at all. No sound, no pressure, no weight. Floating in darkness... free fall, maybe thirty miles up, above the effective atmosphere, falling weightlessly toward the surface of a planet you've never seen. But I'm not shaking now; it's the wait beforehand that wears. Once you unload, you can't get hurt — because if anything goes wrong it will happen so fast that you'll buy it without noticing that you're dead, hardly.
+</p>
+
+<p>
+Almost at once I felt the capsule twist and sway, then steady down so that my weight was on my back...weight that built up quickly until I was at my full weight (0.87 gee, we had been told) for that planet as the capsule reached terminal velocity for the thin upper atmosphere. A pilot who is a real artist (and the Captain was) will approach and brake so that your launching speed as you shoot out of the tube places you just dead in space relative to the rotational speed of the planet at that latitude. The loaded capsules are heavy; they punch through the high, thin winds of the upper atmosphere without being blown too far out of position — but just the same a platoon is bound to disperse on the way down, lose some of the perfect formation in which it unloads. A sloppy pilot can make this still worse, scatter a strike group over so much terrain that it can't make rendezvous for retrieval, much less carry out its mission. An infantryman can fight only if somebody else delivers him to his zone; in a way I suppose pilots are just as essential as we are.
+</p>
+
+<p>
+I could tell from the gentle way my capsule entered the atmosphere that the Captain had laid us down with as near zero lateral vector as you could ask for. I felt happy — not only a tight formation when we hit and no time wasted, but also a pilot who puts you down properly is a pilot who is smart and precise on retrieval.
+</p>
+
+<p>
+The outer shell burned away and sloughed off — unevenly, for I tumbled. Then the rest of it went and I straightened out. The turbulence brakes of the second shell bit in and the ride got rough... and still rougher as they burned off one at a time and the second shell began to go to pieces. One of the things that helps a capsule trooper to live long enough to draw a pension is that the skins peeling off his capsule not only slow him down, they also fill the sky over the target area with so much junk that radar picks up reflections from dozens of targets for each man in the drop, any one of which could be a man, or a bomb, or anything. It's enough to give a ballistic computer nervous breakdowns — and does. To add to the fun your ship lays a series of dummy eggs in the seconds immediately following your drop, dummies that will fall faster because they don't slough. They get under you, explode, throw out "window," even operate as transponders, rocket sideways, and do other things to add to the confusion of your reception committee on the ground.
+</p>
+
+<p>
+In the meantime your ship is locked firmly on the directional beacon of your platoon leader, ignoring the radar "noise" it has created and following you in, computing your impact for future use. When the second shell was gone, the third shell automatically opened my first ribbon chute. It didn't last long but it wasn't expected to; one good, hard jerk at several gee and it went its way and I went mine. The second chute lasted a little bit longer and the third chute lasted quite a while; it began to be rather too warm inside the capsule and I started thinking about landing.
+</p>
+
+<p>
+The third shell peeled off when its last chute was gone and now I had nothing around me but my suit armor and a plastic egg. I was still strapped inside it, unable to move; it was time to decide how and where I was going to ground. Without moving my arms (I couldn't) I thumbed the switch for a proximity reading and read it when it flashed on in the instrument reflector inside my helmet in front of my forehead. A mile and eight-tenths — A little closer than I liked, especially without company. The inner egg had reached steady speed, no more help to be gained by staying inside it, and its skin temperature indicated that it would not open automatically for a while yet — so I flipped a switch with my other thumb and got rid of it.
+</p>
+
+<p>
+The first charge cut all the straps; the second charge exploded the plastic egg away from me in eight separate pieces — and I was outdoors, sitting on air, and could see! Better still, the eight discarded pieces were metal-coated (except for the small bit I had taken proximity reading through) and would give back the same reflection as an armored man. Any radar viewer, alive or cybernetic, would now have a sad time sorting me out from the junk nearest me, not to mention the thousands of other bits and pieces for miles on each side, above, and below me. Part of a mobile infantryman's training is to let him see, from the ground and both by eye and by radar, just how confusing a drop is to the forces on the ground — because you feel awful naked up there. It is easy to panic and either open a chute too soon and become a sitting duck (do ducks really sit? — if so, why?) or fail to open it and break your ankles, likewise backbone and skull. So I stretched, getting the kinks out, and looked around... then doubled up again and straightened out in a swan dive face down and took a good look. It was night down there, as planned, but infrared snoopers let you size up terrain quite well after you are used to them. The river that cut diagonally through the city was almost below me and coming up fast, shining out clearly with a higher temperature than the land. I didn't care which side of it I landed on but I didn't want to land in it; it would slow me down.
+</p>
+
+<p>
+I noticed a dash off to the right at about my altitude; some unfriendly native down below had burned what was probably a piece of my egg. So I fired my first chute at once, intending if possible to jerk myself right off his screen as he followed the targets down in closing range. I braced for the shock, rode it, then floated down for about twenty seconds before unloading the chute — not wishing to call attention to myself in still another way by not falling at the speed of the other stuff around me. It must have worked; I wasn't burned.
+</p>
+
+<p>
+About six hundred feet up I shot the second chute... saw very quickly that I was being carried over into the river, found that I was going to pass about a hundred feet up over a flat-roofed warehouse or some such by the river... blew the chute free and came in for a good enough if rather bouncy landing on the roof by means of the suit's jump jets. I was scanning for Sergeant Jelal's beacon as I hit. And found that I was on the wrong side of the river; Jelly's star showed up on the compass ring inside my helmet far south of where it should have been — I was too far north. I trotted toward the river side of the roof as I took a range and bearing on the squad leader next to me, found that he was over a mile out of position, called, "Ace! dress your line," tossed a bomb behind me as I stepped off the building and across the river. Ace answered as I could have expected — Ace should have had my spot but he didn't want to give up his squad; nevertheless he didn't fancy taking orders from me.
+</p>
+
+<p>
+The warehouse went up behind me and the blast hit me while I was still over the river, instead of being shielded by the buildings on the far side as I should have been. It darn near tumbled my gyros and I came close to tumbling myself. I had set that bomb for fifteen seconds... or had I? I suddenly realized that I had let myself get excited, the worst thing you can do once you're on the ground. "Just like a drill," that was the way, just as Jelly had warned me. Take your time and do it right, even if it takes another half second. As I hit I took another reading on Ace and told him again to realign his squad. He didn't answer but he was already doing it. I let it ride. As long as Ace did his job, I could afford to swallow his surliness — for now. But back aboard ship (if Jelly kept me on as assistant section leader) we would eventually have to pick a quiet spot and find out who was boss. He was a career corporal and I was just a term lance acting as corporal, but he was under me and you can't afford to take any lip under those circumstances. Not permanently.
+</p>
+
+<p>
+But I didn't have time then to think about it; while I was jumping the river I had spotted a juicy target and I wanted to get it before somebody else noticed it — a lovely big group of what looked like public buildings on a hill. Temples, maybe... or a palace. They were miles outside the area we were sweeping, but one rule of a smash & run is to expend at least half your ammo outside your sweep area; that way the enemy is kept confused as to where you actually are — that and keep moving, do everything fast. You're always heavily outnumbered; surprise and speed are what saves you. I was already loading my rocket launcher while I was checking on Ace and telling him for the second time to straighten up. Jelly's voice reached me right on top of that on the all-hands circuit: "Platoon! By leapfrog! Forward!" My boss, Sergeant Johnson, echoed, "By leapfrog! Odd numbers! Advance!" That left me with nothing to worry about for twenty seconds, so I jumped up on the building nearest me, raised the launcher to my shoulder, found the target and pulled the first trigger to let the rocket have a look at its target — pulled the second trigger and kissed it on its way, jumped back to the ground. "Second section, even numbers!" I called out... waited for the count in my mind and ordered, "Advance!"
+</p>
+
+<p>
+And did so myself, hopping over the next row of buildings, and, while I was in the air, fanning the first row by the river front with a hand flamer. They seemed to be wood construction and it looked like time to start a good fire — with luck, some of those warehouses would house oil products, or even explosives. As I hit, the Y-rack on my shoulders launched two small H. E. bombs a couple of hundred yards each way to my right and left flanks but I never saw what they did as just then my first rocket hit — that unmistakable (if you've ever seen one) brilliance of an atomic explosion. It was just a peewee, of course, less than two kilotons nominal yield, with tamper and implosion squeeze to produce results from a less-than-critical mass — but then who wants to be bunk mates with a cosmic catastrophe? It was enough to clean off that hilltop and make everybody in the city take shelter against fallout. Better still, any of the local yokels who happened to be outdoors and looking that way wouldn't be seeing anything else for a couple of hours — meaning me. The dash hadn't dazzled me, nor would it dazzle any of us; our face bowls are heavily leaded, we wear snoopers over our eyes — and we're trained to duck and take it on the armor if we do happen to be looking the wrong way.
+</p>
+
+<p>
+So I merely blinked hard — opened my eyes and stared straight at a local citizen just coming out of an opening in the building ahead of me. He looked at me, I looked at him, and he started to raise something — a weapon, I suppose — as Jelly called out, "Odd numbers! Advance!"
+</p>
+
+<p>
+I didn't have time to fool with him; I was a good five hundred yards short of where I should have been by then. I still had the hand flamer in my left hand; I toasted him and jumped over the building he had been coming out of, as I started to count. A hand flamer is primarily for incendiary work but it is a good defensive anti-personnel weapon in tight quarters; you don't have to aim it much.
+</p>
+
+<p>
+Between excitement and anxiety to catch up I jumped too high and too wide. It's always a temptation to get the most out of your jump gear — but don't do it! It leaves you hanging in the air for seconds, a big fat target. The way to advance is to skim over each building as you come to it, barely clearing it, and taking full advantage of cover while you're down — and never stay in one place more than a second or two, never give them time to target in on you. Be somewhere else, anywhere. Keep moving.
+</p>
+
+<p>
+</p>
+
+<p>This one I goofed — too much for one row of buildings, too little for the row beyond it; I found myself coming down on a roof. But not a nice flat one where I might have tarried three seconds to launch another peewee A-rocket; this roof was a jungle of pipes and stanchions and assorted ironmongery — a factory maybe, or some sort of chemical works. No place to land. Worse still, half a dozen natives were up there. These geezers are humanoid, eight or nine feet tall, much skinnier than we are and with a higher body temperature; they don't wear any clothes and they stand out in a set of snoopers like a neon sign. They look still funnier in daylight with your bare eyes but I would rather fight them than the arachnids — those Bugs make me queezy.
+</p>
+
+<p>
+If these laddies were up there thirty seconds earlier when my rocket hit, then they couldn't see me, or anything. But I couldn't be certain and didn't want to tangle with them in any case; it wasn't that kind of a raid. So I jumped again while I was still in the air, scattering a handful of ten-second fire pills to keep
+them busy, grounded, jumped again at once, and called out, "Second section! Even numbers!...Advance!" and kept right on going to close the gap, while trying to spot, every time I jumped, something worth expending a rocket on. I had three more of the little A-rockets and I certainly didn't intend to take any back with me.
+</p>
+
+<p>
+But I had had pounded into me that you must get your money's worth with atomic weapons — it was only the second time that I had been allowed to carry them. Right now I was trying to spot their waterworks; a direct hit on it could make the whole city uninhabitable, force them to evacuate it without directly killing anyone — just the sort of nuisance we had been sent down to commit. It should — according to the map we had studied under hypnosis — be about three miles upstream from where I was.
+</p>
+
+<p>
+But I couldn't see it; my jumps didn't take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+Fourth and Fifth squads answered, "Wilco"; Ace said, "We're already doin' it — pick up your feet." Red's beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+<p>
+At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I'm no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn't already been told to jump, I guess I wouldn't have got out of there.
+</p>
+
+<p>
+Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+<p>
+There was something on the horizon in the direction of their spaceport — administration & control, maybe, or possibly even a starship. Almost in line and about half as far away was an enormous structure which I couldn't identify even that loosely. The range to the spaceport was extreme but I let the rocket see it, said, "Go find it, baby!" and twisted its tail — slapped the last one in, sent it toward the nearer target, and jumped. That building took a direct hit just as I left it. Either a skinny had judged (correctly) that it was worth one of their buildings to try for one of us, or one of my own mates was getting mighty careless with fireworks. Either way, I didn't want to jump from that spot, even a skimmer; I decided to go through the next couple of buildings instead of over. So I grabbed the heavy flamer off my back as I hit and dipped the snoopers down over my eyes, tackled a wall in front of me with a knife beam at full power. A section of
+wall fell away and I charged in. And backed out even faster. I didn't know what it was I had cracked open. A congregation in church — a skinny flophouse —
+maybe even their defense headquarters. All I knew was that it was a very big room filled with more skinnies than I wanted to see in my whole life.
+</p>
+
+<p>
+Probably not a church, for somebody took a shot at me as I popped back out just a slug that bounced off my armor, made my ears ring, and staggered me without hurting me. But it reminded me that I wasn't supposed to leave without giving them a souvenir of my visit. I grabbed the first thing on my belt and lobbed it in — and heard it start to squawk. As they keep telling you in Basic, doing something constructive at once is better than figuring out the best thing to do hours later. By sheer chance I had done the right thing. This was a special bomb, one each issued to us for this mission with instructions to use them if we found ways to make them effective. The squawking I heard as I threw it was the bomb shouting in skinny talk (free translation): "I'm a thirty-second bomb! I'm a thirty-second bomb! Twenty-nine!... twenty-eight!... twenty-seven! — "It was supposed to frazzle their nerves. Maybe it did; it certainly frazzled mine. Kinder to shoot a man. I didn't wait for the countdown; I jumped, while I wondered whether they would find enough doors and windows to swarm out in time.
+</p>
+
+<p>
+I got a bearing on Red's blinker at the top of the jump and one on Ace as I grounded. I was falling behind again — time to hurry. But three minutes later we had closed the gap; I had Red on my left flank a half mile away. He reported it to Jelly. We heard Jelly's relaxed growl to the entire platoon: "Circle is closed, but the beacon is not down yet. Move forward slowly and mill around, make a little more trouble — but mind the lad on each side of you; don't make trouble for him. Good job, so far — don't spoil it. Platoon! By sections...Muster!"
+</p>
+
+<p>
+It looked like a good job to me, too; much of the city was burning and, although it was almost full light now, it was hard to tell whether bare eyes were better than snoopers, the smoke was so thick. Johnson, our section leader, sounded off: "Second section, call off!" I echoed, "Squads four, five, and six — call off and report!" The assortment of safe circuits we had available in the new model comm units certainly speeded things up; Jelly could talk to anybody or to his section leaders; a section leader could call his whole section, or his non-coms; and the platoon could muster twice as fast, when seconds matter. I listened to the fourth squad call off while I inventoried my remaining firepower and lobbed one bomb toward a skinny who poked his head around a corner. He left and so did I — "Mill around," the boss man had said.
+</p>
+
+<p>
+The fourth squad bumbled the call off until the squad leader remembered to fill in with Jenkins' number; the fifth squad clicked off like an abacus and I began to feel good . . . when the call off stopped after number four in Ace's squad. I called out, "Ace, where's Dizzy?"
+</p>
+
+<p>
+"Shut up," he said. "Number six! Call off!"
+</p>
+
+<p>
+"Six!" Smith answered.
+</p>
+
+<p>
+"Seven!"
+</p>
+
+<p>
+"Sixth squad, Flores missing," Ace completed it. "Squad leader out for pickup."
+</p>
+
+<p>
+"One man absent," I reported to Johnson. "Flores, squad six."
+</p>
+
+<p>
+"Missing or dead?"
+</p>
+
+<p>
+"I don't know. Squad leader and assistant section leader dropping out for pickup."
+</p>
+
+<p>
+"Johnnie, you let Ace take it."
+</p>
+
+<p>
+But I didn't hear him, so I didn't answer. I heard him report to Jelly and I heard Jelly cuss. Now look, I wasn't bucking for a medal — it's the assistant section leader's business to make pickup; he's the chaser, the last man in, expendable. The squad leaders have other work to do. As you've no doubt gathered by now the assistant section leader isn't necessary as long as the section leader is alive. Right that moment I was feeling unusually expendable, almost expended, because I was hearing the sweetest sound in the universe, the beacon the retrieval boat would land on, sounding our recall. The beacon is a robot rocket, fired ahead of the retrieval boat, just a spike that buries itself in the ground and starts broadcasting that welcome, welcome music. The retrieval boat homes in on it automatically three minutes later and you had better be on hand, because the bus can't wait and there won't be another one along.
+</p>
+
+<p>
+But you don't walk away on another cap trooper, not while there's a chance he's still alive — not in Rasczak's Roughnecks. Not in any outfit of the Mobile Infantry. You try to make pickup. I heard Jelly order: "Heads up, lads! Close to retrieval circle and interdict! On the bounce!"
+</p>
+
+<p>
+And I heard the beacon's sweet voice: " — to the everlasting glory of the infantry, shines the name, shines the name of Rodger Young!" and I wanted to head for it so bad I could taste it.
+</p>
+
+<p>
+Instead I was headed the other way, closing on Ace's beacon and expending what I had left of bombs and fire pills and anything else that would weigh me down. "Ace! You got his beacon?"
+</p>
+
+<p>
+"Yes. Go back, Useless!"
+</p>
+
+<p>
+"I've got you by eye now. Where is he?"
+</p>
+
+<p>
+"Right ahead of me, maybe quarter mile. Scram! He's my man ."
+</p>
+
+<p>
+I didn't answer; I simply cut left oblique to reach Ace about where he said Dizzy was.
+</p>
+
+<p>
+And found Ace standing over him, a couple of skinnies flamed down and more running away. I lit beside him. "Let's get him out of his armor — the boat'll be down any second!"
+</p>
+
+<p>
+"He's too bad hurt!"
+</p>
+
+<p>
+I looked and saw that it was true — there was actually a hole in his armor and blood coming out. And I was stumped. To make a wounded pickup you get him out of his armor... then you simply pick him up in your arms — no trouble in a powered suit — and bounce away from there. A bare man weighs less than the ammo and stuff you've expended. "What'll we do?"
+</p>
+
+<p>
+"We carry him," Ace said grimly. "Grab ahold the left side of his belt." He grabbed the right side, we manhandled Flores to his feet. "Lock on! Now... by the numbers, stand by to jump — one — two!"
+</p>
+
+<p>
+We jumped. Not far, not well. One man alone couldn't have gotten him off the ground; an armored suit is too heavy. But split it between two men and it can be done.
+We jumped — and we jumped — and again, and again, with Ace calling it and both of us steadying and catching Dizzy on each grounding. His gyros seemed to be out.
+</p>
+
+<p>
+We heard the beacon cut off as the retrieval boat landed on it — I saw it land . . . and it was too far away. We heard the acting platoon sergeant call out: "In succession, prepare to embark!"
+</p>
+
+<p>
+And Jelly called out, "Belay that order!"
+</p>
+
+<p>
+We broke at last into the open and saw the boat standing on its tail, heard the ululation of its take-off warning — saw the platoon still on the ground around it, in interdiction circle, crouching behind the shield they had formed. Heard Jelly shout, "In succession, man the boat — move!"
+</p>
+
+<p>
+And we were still too far away! I could see them peel off from the first squad, swarm into the boat as the interdiction circle tightened. And a single figure broke out of the circle, came toward us at a speed possible only to a command suit. Jelly caught us while we were in the air, grabbed Flores by his Y-rack and helped us lift. Three jumps got us to the boat. Everybody else was inside but the door was still open. We got him in and closed it while the boat pilot screamed that we had made her miss rendezvous and now we had all bought it! Jelly paid no attention to her; we laid Flores down and lay down beside him. As the blast hit us Jelly was saying to himself, "All present, Lieutenant. Three men hurt — but all present!"
+</p>
+
+<p>
+I'll say this for Captain Deladrier: they don't make any better pilots. A rendezvous, boat to ship in orbit, is precisely calculated. I don't know how, but it is, and you don't change it. You can't.
+</p>
+
+<p>
+Only she did. She saw in her scope that the boat had failed to blast on time; she braked back, picked up speed again — and matched and took us in, just by eye and touch, no time to compute it. If the Almighty ever needs an assistant to keep the stars in their courses, I know where he can look.
+</p>
+
+<p>
+Flores died on the way up.
+</p>
+
+<p>
+ -- repeat --
+</p>
+
+<p>
+Then suddenly nothing. Nothing at all. No sound, no pressure, no weight. Floating in darkness... free fall, maybe thirty miles up, above the effective atmosphere, falling weightlessly toward the surface of a planet you've never seen. But I'm not shaking now; it's the wait beforehand that wears. Once you unload, you can't get hurt — because if anything goes wrong it will happen so fast that you'll buy it without noticing that you're dead, hardly.
+</p>
+
+<p>
+Almost at once I felt the capsule twist and sway, then steady down so that my weight was on my back...weight that built up quickly until I was at my full weight (0.87 gee, we had been told) for that planet as the capsule reached terminal velocity for the thin upper atmosphere. A pilot who is a real artist (and the Captain was) will approach and brake so that your launching speed as you shoot out of the tube places you just dead in space relative to the rotational speed of the planet at that latitude. The loaded capsules are heavy; they punch through the high, thin winds of the upper atmosphere without being blown too far out of position — but just the same a platoon is bound to disperse on the way down, lose some of the perfect formation in which it unloads. A sloppy pilot can make this still worse, scatter a strike group over so much terrain that it can't make rendezvous for retrieval, much less carry out its mission. An infantryman can fight only if somebody else delivers him to his zone; in a way I suppose pilots are just as essential as we are.
+</p>
+
+<p>
+I could tell from the gentle way my capsule entered the atmosphere that the Captain had laid us down with as near zero lateral vector as you could ask for. I felt happy — not only a tight formation when we hit and no time wasted, but also a pilot who puts you down properly is a pilot who is smart and precise on retrieval.
+</p>
+
+<p>
+The outer shell burned away and sloughed off — unevenly, for I tumbled. Then the rest of it went and I straightened out. The turbulence brakes of the second shell bit in and the ride got rough... and still rougher as they burned off one at a time and the second shell began to go to pieces. One of the things that helps a capsule trooper to live long enough to draw a pension is that the skins peeling off his capsule not only slow him down, they also fill the sky over the target area with so much junk that radar picks up reflections from dozens of targets for each man in the drop, any one of which could be a man, or a bomb, or anything. It's enough to give a ballistic computer nervous breakdowns — and does. To add to the fun your ship lays a series of dummy eggs in the seconds immediately following your drop, dummies that will fall faster because they don't slough. They get under you, explode, throw out "window," even operate as transponders, rocket sideways, and do other things to add to the confusion of your reception committee on the ground.
+</p>
+
+<p>
+In the meantime your ship is locked firmly on the directional beacon of your platoon leader, ignoring the radar "noise" it has created and following you in, computing your impact for future use. When the second shell was gone, the third shell automatically opened my first ribbon chute. It didn't last long but it wasn't expected to; one good, hard jerk at several gee and it went its way and I went mine. The second chute lasted a little bit longer and the third chute lasted quite a while; it began to be rather too warm inside the capsule and I started thinking about landing.
+</p>
+
+<p>
+The third shell peeled off when its last chute was gone and now I had nothing around me but my suit armor and a plastic egg. I was still strapped inside it, unable to move; it was time to decide how and where I was going to ground. Without moving my arms (I couldn't) I thumbed the switch for a proximity reading and read it when it flashed on in the instrument reflector inside my helmet in front of my forehead. A mile and eight-tenths — A little closer than I liked, especially without company. The inner egg had reached steady speed, no more help to be gained by staying inside it, and its skin temperature indicated that it would not open automatically for a while yet — so I flipped a switch with my other thumb and got rid of it.
+</p>
+
+<p>
+The first charge cut all the straps; the second charge exploded the plastic egg away from me in eight separate pieces — and I was outdoors, sitting on air, and could see! Better still, the eight discarded pieces were metal-coated (except for the small bit I had taken proximity reading through) and would give back the same reflection as an armored man. Any radar viewer, alive or cybernetic, would now have a sad time sorting me out from the junk nearest me, not to mention the thousands of other bits and pieces for miles on each side, above, and below me. Part of a mobile infantryman's training is to let him see, from the ground and both by eye and by radar, just how confusing a drop is to the forces on the ground — because you feel awful naked up there. It is easy to panic and either open a chute too soon and become a sitting duck (do ducks really sit? — if so, why?) or fail to open it and break your ankles, likewise backbone and skull. So I stretched, getting the kinks out, and looked around... then doubled up again and straightened out in a swan dive face down and took a good look. It was night down there, as planned, but infrared snoopers let you size up terrain quite well after you are used to them. The river that cut diagonally through the city was almost below me and coming up fast, shining out clearly with a higher temperature than the land. I didn't care which side of it I landed on but I didn't want to land in it; it would slow me down.
+</p>
+
+<p>
+I noticed a dash off to the right at about my altitude; some unfriendly native down below had burned what was probably a piece of my egg. So I fired my first chute at once, intending if possible to jerk myself right off his screen as he followed the targets down in closing range. I braced for the shock, rode it, then floated down for about twenty seconds before unloading the chute — not wishing to call attention to myself in still another way by not falling at the speed of the other stuff around me. It must have worked; I wasn't burned.
+</p>
+
+<p>
+About six hundred feet up I shot the second chute... saw very quickly that I was being carried over into the river, found that I was going to pass about a hundred feet up over a flat-roofed warehouse or some such by the river... blew the chute free and came in for a good enough if rather bouncy landing on the roof by means of the suit's jump jets. I was scanning for Sergeant Jelal's beacon as I hit. And found that I was on the wrong side of the river; Jelly's star showed up on the compass ring inside my helmet far south of where it should have been — I was too far north. I trotted toward the river side of the roof as I took a range and bearing on the squad leader next to me, found that he was over a mile out of position, called, "Ace! dress your line," tossed a bomb behind me as I stepped off the building and across the river. Ace answered as I could have expected — Ace should have had my spot but he didn't want to give up his squad; nevertheless he didn't fancy taking orders from me.
+</p>
+
+<p>
+The warehouse went up behind me and the blast hit me while I was still over the river, instead of being shielded by the buildings on the far side as I should have been. It darn near tumbled my gyros and I came close to tumbling myself. I had set that bomb for fifteen seconds... or had I? I suddenly realized that I had let myself get excited, the worst thing you can do once you're on the ground. "Just like a drill," that was the way, just as Jelly had warned me. Take your time and do it right, even if it takes another half second. As I hit I took another reading on Ace and told him again to realign his squad. He didn't answer but he was already doing it. I let it ride. As long as Ace did his job, I could afford to swallow his surliness — for now. But back aboard ship (if Jelly kept me on as assistant section leader) we would eventually have to pick a quiet spot and find out who was boss. He was a career corporal and I was just a term lance acting as corporal, but he was under me and you can't afford to take any lip under those circumstances. Not permanently.
+</p>
+
+<p>
+But I didn't have time then to think about it; while I was jumping the river I had spotted a juicy target and I wanted to get it before somebody else noticed it — a lovely big group of what looked like public buildings on a hill. Temples, maybe... or a palace. They were miles outside the area we were sweeping, but one rule of a smash & run is to expend at least half your ammo outside your sweep area; that way the enemy is kept confused as to where you actually are — that and keep moving, do everything fast. You're always heavily outnumbered; surprise and speed are what saves you. I was already loading my rocket launcher while I was checking on Ace and telling him for the second time to straighten up. Jelly's voice reached me right on top of that on the all-hands circuit: "Platoon! By leapfrog! Forward!" My boss, Sergeant Johnson, echoed, "By leapfrog! Odd numbers! Advance!" That left me with nothing to worry about for twenty seconds, so I jumped up on the building nearest me, raised the launcher to my shoulder, found the target and pulled the first trigger to let the rocket have a look at its target — pulled the second trigger and kissed it on its way, jumped back to the ground. "Second section, even numbers!" I called out... waited for the count in my mind and ordered, "Advance!"
+</p>
+
+<p>
+And did so myself, hopping over the next row of buildings, and, while I was in the air, fanning the first row by the river front with a hand flamer. They seemed to be wood construction and it looked like time to start a good fire — with luck, some of those warehouses would house oil products, or even explosives. As I hit, the Y-rack on my shoulders launched two small H. E. bombs a couple of hundred yards each way to my right and left flanks but I never saw what they did as just then my first rocket hit — that unmistakable (if you've ever seen one) brilliance of an atomic explosion. It was just a peewee, of course, less than two kilotons nominal yield, with tamper and implosion squeeze to produce results from a less-than-critical mass — but then who wants to be bunk mates with a cosmic catastrophe? It was enough to clean off that hilltop and make everybody in the city take shelter against fallout. Better still, any of the local yokels who happened to be outdoors and looking that way wouldn't be seeing anything else for a couple of hours — meaning me. The dash hadn't dazzled me, nor would it dazzle any of us; our face bowls are heavily leaded, we wear snoopers over our eyes — and we're trained to duck and take it on the armor if we do happen to be looking the wrong way.
+</p>
+
+<p>
+So I merely blinked hard — opened my eyes and stared straight at a local citizen just coming out of an opening in the building ahead of me. He looked at me, I looked at him, and he started to raise something — a weapon, I suppose — as Jelly called out, "Odd numbers! Advance!"
+</p>
+
+<p>
+I didn't have time to fool with him; I was a good five hundred yards short of where I should have been by then. I still had the hand flamer in my left hand; I toasted him and jumped over the building he had been coming out of, as I started to count. A hand flamer is primarily for incendiary work but it is a good defensive anti-personnel weapon in tight quarters; you don't have to aim it much.
+</p>
+
+<p>
+Between excitement and anxiety to catch up I jumped too high and too wide. It's always a temptation to get the most out of your jump gear — but don't do it! It leaves you hanging in the air for seconds, a big fat target. The way to advance is to skim over each building as you come to it, barely clearing it, and taking full advantage of cover while you're down — and never stay in one place more than a second or two, never give them time to target in on you. Be somewhere else, anywhere. Keep moving.
+</p>
+
+<p>
+</p>
+
+<p>This one I goofed — too much for one row of buildings, too little for the row beyond it; I found myself coming down on a roof. But not a nice flat one where I might have tarried three seconds to launch another peewee A-rocket; this roof was a jungle of pipes and stanchions and assorted ironmongery — a factory maybe, or some sort of chemical works. No place to land. Worse still, half a dozen natives were up there. These geezers are humanoid, eight or nine feet tall, much skinnier than we are and with a higher body temperature; they don't wear any clothes and they stand out in a set of snoopers like a neon sign. They look still funnier in daylight with your bare eyes but I would rather fight them than the arachnids — those Bugs make me queezy.
+</p>
+
+<p>
+If these laddies were up there thirty seconds earlier when my rocket hit, then they couldn't see me, or anything. But I couldn't be certain and didn't want to tangle with them in any case; it wasn't that kind of a raid. So I jumped again while I was still in the air, scattering a handful of ten-second fire pills to keep
+them busy, grounded, jumped again at once, and called out, "Second section! Even numbers!...Advance!" and kept right on going to close the gap, while trying to spot, every time I jumped, something worth expending a rocket on. I had three more of the little A-rockets and I certainly didn't intend to take any back with me.
+</p>
+
+<p>
+But I had had pounded into me that you must get your money's worth with atomic weapons — it was only the second time that I had been allowed to carry them. Right now I was trying to spot their waterworks; a direct hit on it could make the whole city uninhabitable, force them to evacuate it without directly killing anyone — just the sort of nuisance we had been sent down to commit. It should — according to the map we had studied under hypnosis — be about three miles upstream from where I was.
+</p>
+
+<p>
+But I couldn't see it; my jumps didn't take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+Fourth and Fifth squads answered, "Wilco"; Ace said, "We're already doin' it — pick up your feet." Red's beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+<p>
+At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I'm no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn't already been told to jump, I guess I wouldn't have got out of there.
+</p>
+
+<p>
+Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+<p>
+There was something on the horizon in the direction of their spaceport — administration & control, maybe, or possibly even a starship. Almost in line and about half as far away was an enormous structure which I couldn't identify even that loosely. The range to the spaceport was extreme but I let the rocket see it, said, "Go find it, baby!" and twisted its tail — slapped the last one in, sent it toward the nearer target, and jumped. That building took a direct hit just as I left it. Either a skinny had judged (correctly) that it was worth one of their buildings to try for one of us, or one of my own mates was getting mighty careless with fireworks. Either way, I didn't want to jump from that spot, even a skimmer; I decided to go through the next couple of buildings instead of over. So I grabbed the heavy flamer off my back as I hit and dipped the snoopers down over my eyes, tackled a wall in front of me with a knife beam at full power. A section of
+wall fell away and I charged in. And backed out even faster. I didn't know what it was I had cracked open. A congregation in church — a skinny flophouse —
+maybe even their defense headquarters. All I knew was that it was a very big room filled with more skinnies than I wanted to see in my whole life.
+</p>
+
+<p>
+Probably not a church, for somebody took a shot at me as I popped back out just a slug that bounced off my armor, made my ears ring, and staggered me without hurting me. But it reminded me that I wasn't supposed to leave without giving them a souvenir of my visit. I grabbed the first thing on my belt and lobbed it in — and heard it start to squawk. As they keep telling you in Basic, doing something constructive at once is better than figuring out the best thing to do hours later. By sheer chance I had done the right thing. This was a special bomb, one each issued to us for this mission with instructions to use them if we found ways to make them effective. The squawking I heard as I threw it was the bomb shouting in skinny talk (free translation): "I'm a thirty-second bomb! I'm a thirty-second bomb! Twenty-nine!... twenty-eight!... twenty-seven! — "It was supposed to frazzle their nerves. Maybe it did; it certainly frazzled mine. Kinder to shoot a man. I didn't wait for the countdown; I jumped, while I wondered whether they would find enough doors and windows to swarm out in time.
+</p>
+
+<p>
+I got a bearing on Red's blinker at the top of the jump and one on Ace as I grounded. I was falling behind again — time to hurry. But three minutes later we had closed the gap; I had Red on my left flank a half mile away. He reported it to Jelly. We heard Jelly's relaxed growl to the entire platoon: "Circle is closed, but the beacon is not down yet. Move forward slowly and mill around, make a little more trouble — but mind the lad on each side of you; don't make trouble for him. Good job, so far — don't spoil it. Platoon! By sections...Muster!"
+</p>
+
+<p>
+It looked like a good job to me, too; much of the city was burning and, although it was almost full light now, it was hard to tell whether bare eyes were better than snoopers, the smoke was so thick. Johnson, our section leader, sounded off: "Second section, call off!" I echoed, "Squads four, five, and six — call off and report!" The assortment of safe circuits we had available in the new model comm units certainly speeded things up; Jelly could talk to anybody or to his section leaders; a section leader could call his whole section, or his non-coms; and the platoon could muster twice as fast, when seconds matter. I listened to the fourth squad call off while I inventoried my remaining firepower and lobbed one bomb toward a skinny who poked his head around a corner. He left and so did I — "Mill around," the boss man had said.
+</p>
+
+<p>
+The fourth squad bumbled the call off until the squad leader remembered to fill in with Jenkins' number; the fifth squad clicked off like an abacus and I began to feel good . . . when the call off stopped after number four in Ace's squad. I called out, "Ace, where's Dizzy?"
+</p>
+
+<p>
+"Shut up," he said. "Number six! Call off!"
+</p>
+
+<p>
+"Six!" Smith answered.
+</p>
+
+<p>
+"Seven!"
+</p>
+
+<p>
+"Sixth squad, Flores missing," Ace completed it. "Squad leader out for pickup."
+</p>
+
+<p>
+"One man absent," I reported to Johnson. "Flores, squad six."
+</p>
+
+<p>
+"Missing or dead?"
+</p>
+
+<p>
+"I don't know. Squad leader and assistant section leader dropping out for pickup."
+</p>
+
+<p>
+"Johnnie, you let Ace take it."
+</p>
+
+<p>
+But I didn't hear him, so I didn't answer. I heard him report to Jelly and I heard Jelly cuss. Now look, I wasn't bucking for a medal — it's the assistant section leader's business to make pickup; he's the chaser, the last man in, expendable. The squad leaders have other work to do. As you've no doubt gathered by now the assistant section leader isn't necessary as long as the section leader is alive. Right that moment I was feeling unusually expendable, almost expended, because I was hearing the sweetest sound in the universe, the beacon the retrieval boat would land on, sounding our recall. The beacon is a robot rocket, fired ahead of the retrieval boat, just a spike that buries itself in the ground and starts broadcasting that welcome, welcome music. The retrieval boat homes in on it automatically three minutes later and you had better be on hand, because the bus can't wait and there won't be another one along.
+</p>
+
+<p>
+But you don't walk away on another cap trooper, not while there's a chance he's still alive — not in Rasczak's Roughnecks. Not in any outfit of the Mobile Infantry. You try to make pickup. I heard Jelly order: "Heads up, lads! Close to retrieval circle and interdict! On the bounce!"
+</p>
+
+<p>
+And I heard the beacon's sweet voice: " — to the everlasting glory of the infantry, shines the name, shines the name of Rodger Young!" and I wanted to head for it so bad I could taste it.
+</p>
+
+<p>
+Instead I was headed the other way, closing on Ace's beacon and expending what I had left of bombs and fire pills and anything else that would weigh me down. "Ace! You got his beacon?"
+</p>
+
+<p>
+"Yes. Go back, Useless!"
+</p>
+
+<p>
+"I've got you by eye now. Where is he?"
+</p>
+
+<p>
+"Right ahead of me, maybe quarter mile. Scram! He's my man ."
+</p>
+
+<p>
+I didn't answer; I simply cut left oblique to reach Ace about where he said Dizzy was.
+</p>
+
+<p>
+And found Ace standing over him, a couple of skinnies flamed down and more running away. I lit beside him. "Let's get him out of his armor — the boat'll be down any second!"
+</p>
+
+<p>
+"He's too bad hurt!"
+</p>
+
+<p>
+I looked and saw that it was true — there was actually a hole in his armor and blood coming out. And I was stumped. To make a wounded pickup you get him out of his armor... then you simply pick him up in your arms — no trouble in a powered suit — and bounce away from there. A bare man weighs less than the ammo and stuff you've expended. "What'll we do?"
+</p>
+
+<p>
+"We carry him," Ace said grimly. "Grab ahold the left side of his belt." He grabbed the right side, we manhandled Flores to his feet. "Lock on! Now... by the numbers, stand by to jump — one — two!"
+</p>
+
+<p>
+We jumped. Not far, not well. One man alone couldn't have gotten him off the ground; an armored suit is too heavy. But split it between two men and it can be done.
+We jumped — and we jumped — and again, and again, with Ace calling it and both of us steadying and catching Dizzy on each grounding. His gyros seemed to be out.
+</p>
+
+<p>
+We heard the beacon cut off as the retrieval boat landed on it — I saw it land . . . and it was too far away. We heard the acting platoon sergeant call out: "In succession, prepare to embark!"
+</p>
+
+<p>
+And Jelly called out, "Belay that order!"
+</p>
+
+<p>
+We broke at last into the open and saw the boat standing on its tail, heard the ululation of its take-off warning — saw the platoon still on the ground around it, in interdiction circle, crouching behind the shield they had formed. Heard Jelly shout, "In succession, man the boat — move!"
+</p>
+
+<p>
+And we were still too far away! I could see them peel off from the first squad, swarm into the boat as the interdiction circle tightened. And a single figure broke out of the circle, came toward us at a speed possible only to a command suit. Jelly caught us while we were in the air, grabbed Flores by his Y-rack and helped us lift. Three jumps got us to the boat. Everybody else was inside but the door was still open. We got him in and closed it while the boat pilot screamed that we had made her miss rendezvous and now we had all bought it! Jelly paid no attention to her; we laid Flores down and lay down beside him. As the blast hit us Jelly was saying to himself, "All present, Lieutenant. Three men hurt — but all present!"
+</p>
+
+<p>
+I'll say this for Captain Deladrier: they don't make any better pilots. A rendezvous, boat to ship in orbit, is precisely calculated. I don't know how, but it is, and you don't change it. You can't.
+</p>
+
+<p>
+Only she did. She saw in her scope that the boat had failed to blast on time; she braked back, picked up speed again — and matched and took us in, just by eye and touch, no time to compute it. If the Almighty ever needs an assistant to keep the stars in their courses, I know where he can look.
+</p>
+
+<p>
+Flores died on the way up.
+</p>
+
+<p>
+ -- repeat --
+</p>
+
+<p>
+Then suddenly nothing. Nothing at all. No sound, no pressure, no weight. Floating in darkness... free fall, maybe thirty miles up, above the effective atmosphere, falling weightlessly toward the surface of a planet you've never seen. But I'm not shaking now; it's the wait beforehand that wears. Once you unload, you can't get hurt — because if anything goes wrong it will happen so fast that you'll buy it without noticing that you're dead, hardly.
+</p>
+
+<p>
+Almost at once I felt the capsule twist and sway, then steady down so that my weight was on my back...weight that built up quickly until I was at my full weight (0.87 gee, we had been told) for that planet as the capsule reached terminal velocity for the thin upper atmosphere. A pilot who is a real artist (and the Captain was) will approach and brake so that your launching speed as you shoot out of the tube places you just dead in space relative to the rotational speed of the planet at that latitude. The loaded capsules are heavy; they punch through the high, thin winds of the upper atmosphere without being blown too far out of position — but just the same a platoon is bound to disperse on the way down, lose some of the perfect formation in which it unloads. A sloppy pilot can make this still worse, scatter a strike group over so much terrain that it can't make rendezvous for retrieval, much less carry out its mission. An infantryman can fight only if somebody else delivers him to his zone; in a way I suppose pilots are just as essential as we are.
+</p>
+
+<p>
+I could tell from the gentle way my capsule entered the atmosphere that the Captain had laid us down with as near zero lateral vector as you could ask for. I felt happy — not only a tight formation when we hit and no time wasted, but also a pilot who puts you down properly is a pilot who is smart and precise on retrieval.
+</p>
+
+<p>
+The outer shell burned away and sloughed off — unevenly, for I tumbled. Then the rest of it went and I straightened out. The turbulence brakes of the second shell bit in and the ride got rough... and still rougher as they burned off one at a time and the second shell began to go to pieces. One of the things that helps a capsule trooper to live long enough to draw a pension is that the skins peeling off his capsule not only slow him down, they also fill the sky over the target area with so much junk that radar picks up reflections from dozens of targets for each man in the drop, any one of which could be a man, or a bomb, or anything. It's enough to give a ballistic computer nervous breakdowns — and does. To add to the fun your ship lays a series of dummy eggs in the seconds immediately following your drop, dummies that will fall faster because they don't slough. They get under you, explode, throw out "window," even operate as transponders, rocket sideways, and do other things to add to the confusion of your reception committee on the ground.
+</p>
+
+<p>
+In the meantime your ship is locked firmly on the directional beacon of your platoon leader, ignoring the radar "noise" it has created and following you in, computing your impact for future use. When the second shell was gone, the third shell automatically opened my first ribbon chute. It didn't last long but it wasn't expected to; one good, hard jerk at several gee and it went its way and I went mine. The second chute lasted a little bit longer and the third chute lasted quite a while; it began to be rather too warm inside the capsule and I started thinking about landing.
+</p>
+
+<p>
+The third shell peeled off when its last chute was gone and now I had nothing around me but my suit armor and a plastic egg. I was still strapped inside it, unable to move; it was time to decide how and where I was going to ground. Without moving my arms (I couldn't) I thumbed the switch for a proximity reading and read it when it flashed on in the instrument reflector inside my helmet in front of my forehead. A mile and eight-tenths — A little closer than I liked, especially without company. The inner egg had reached steady speed, no more help to be gained by staying inside it, and its skin temperature indicated that it would not open automatically for a while yet — so I flipped a switch with my other thumb and got rid of it.
+</p>
+
+<p>
+The first charge cut all the straps; the second charge exploded the plastic egg away from me in eight separate pieces — and I was outdoors, sitting on air, and could see! Better still, the eight discarded pieces were metal-coated (except for the small bit I had taken proximity reading through) and would give back the same reflection as an armored man. Any radar viewer, alive or cybernetic, would now have a sad time sorting me out from the junk nearest me, not to mention the thousands of other bits and pieces for miles on each side, above, and below me. Part of a mobile infantryman's training is to let him see, from the ground and both by eye and by radar, just how confusing a drop is to the forces on the ground — because you feel awful naked up there. It is easy to panic and either open a chute too soon and become a sitting duck (do ducks really sit? — if so, why?) or fail to open it and break your ankles, likewise backbone and skull. So I stretched, getting the kinks out, and looked around... then doubled up again and straightened out in a swan dive face down and took a good look. It was night down there, as planned, but infrared snoopers let you size up terrain quite well after you are used to them. The river that cut diagonally through the city was almost below me and coming up fast, shining out clearly with a higher temperature than the land. I didn't care which side of it I landed on but I didn't want to land in it; it would slow me down.
+</p>
+
+<p>
+I noticed a dash off to the right at about my altitude; some unfriendly native down below had burned what was probably a piece of my egg. So I fired my first chute at once, intending if possible to jerk myself right off his screen as he followed the targets down in closing range. I braced for the shock, rode it, then floated down for about twenty seconds before unloading the chute — not wishing to call attention to myself in still another way by not falling at the speed of the other stuff around me. It must have worked; I wasn't burned.
+</p>
+
+<p>
+About six hundred feet up I shot the second chute... saw very quickly that I was being carried over into the river, found that I was going to pass about a hundred feet up over a flat-roofed warehouse or some such by the river... blew the chute free and came in for a good enough if rather bouncy landing on the roof by means of the suit's jump jets. I was scanning for Sergeant Jelal's beacon as I hit. And found that I was on the wrong side of the river; Jelly's star showed up on the compass ring inside my helmet far south of where it should have been — I was too far north. I trotted toward the river side of the roof as I took a range and bearing on the squad leader next to me, found that he was over a mile out of position, called, "Ace! dress your line," tossed a bomb behind me as I stepped off the building and across the river. Ace answered as I could have expected — Ace should have had my spot but he didn't want to give up his squad; nevertheless he didn't fancy taking orders from me.
+</p>
+
+<p>
+The warehouse went up behind me and the blast hit me while I was still over the river, instead of being shielded by the buildings on the far side as I should have been. It darn near tumbled my gyros and I came close to tumbling myself. I had set that bomb for fifteen seconds... or had I? I suddenly realized that I had let myself get excited, the worst thing you can do once you're on the ground. "Just like a drill," that was the way, just as Jelly had warned me. Take your time and do it right, even if it takes another half second. As I hit I took another reading on Ace and told him again to realign his squad. He didn't answer but he was already doing it. I let it ride. As long as Ace did his job, I could afford to swallow his surliness — for now. But back aboard ship (if Jelly kept me on as assistant section leader) we would eventually have to pick a quiet spot and find out who was boss. He was a career corporal and I was just a term lance acting as corporal, but he was under me and you can't afford to take any lip under those circumstances. Not permanently.
+</p>
+
+<p>
+But I didn't have time then to think about it; while I was jumping the river I had spotted a juicy target and I wanted to get it before somebody else noticed it — a lovely big group of what looked like public buildings on a hill. Temples, maybe... or a palace. They were miles outside the area we were sweeping, but one rule of a smash & run is to expend at least half your ammo outside your sweep area; that way the enemy is kept confused as to where you actually are — that and keep moving, do everything fast. You're always heavily outnumbered; surprise and speed are what saves you. I was already loading my rocket launcher while I was checking on Ace and telling him for the second time to straighten up. Jelly's voice reached me right on top of that on the all-hands circuit: "Platoon! By leapfrog! Forward!" My boss, Sergeant Johnson, echoed, "By leapfrog! Odd numbers! Advance!" That left me with nothing to worry about for twenty seconds, so I jumped up on the building nearest me, raised the launcher to my shoulder, found the target and pulled the first trigger to let the rocket have a look at its target — pulled the second trigger and kissed it on its way, jumped back to the ground. "Second section, even numbers!" I called out... waited for the count in my mind and ordered, "Advance!"
+</p>
+
+<p>
+And did so myself, hopping over the next row of buildings, and, while I was in the air, fanning the first row by the river front with a hand flamer. They seemed to be wood construction and it looked like time to start a good fire — with luck, some of those warehouses would house oil products, or even explosives. As I hit, the Y-rack on my shoulders launched two small H. E. bombs a couple of hundred yards each way to my right and left flanks but I never saw what they did as just then my first rocket hit — that unmistakable (if you've ever seen one) brilliance of an atomic explosion. It was just a peewee, of course, less than two kilotons nominal yield, with tamper and implosion squeeze to produce results from a less-than-critical mass — but then who wants to be bunk mates with a cosmic catastrophe? It was enough to clean off that hilltop and make everybody in the city take shelter against fallout. Better still, any of the local yokels who happened to be outdoors and looking that way wouldn't be seeing anything else for a couple of hours — meaning me. The dash hadn't dazzled me, nor would it dazzle any of us; our face bowls are heavily leaded, we wear snoopers over our eyes — and we're trained to duck and take it on the armor if we do happen to be looking the wrong way.
+</p>
+
+<p>
+So I merely blinked hard — opened my eyes and stared straight at a local citizen just coming out of an opening in the building ahead of me. He looked at me, I looked at him, and he started to raise something — a weapon, I suppose — as Jelly called out, "Odd numbers! Advance!"
+</p>
+
+<p>
+I didn't have time to fool with him; I was a good five hundred yards short of where I should have been by then. I still had the hand flamer in my left hand; I toasted him and jumped over the building he had been coming out of, as I started to count. A hand flamer is primarily for incendiary work but it is a good defensive anti-personnel weapon in tight quarters; you don't have to aim it much.
+</p>
+
+<p>
+Between excitement and anxiety to catch up I jumped too high and too wide. It's always a temptation to get the most out of your jump gear — but don't do it! It leaves you hanging in the air for seconds, a big fat target. The way to advance is to skim over each building as you come to it, barely clearing it, and taking full advantage of cover while you're down — and never stay in one place more than a second or two, never give them time to target in on you. Be somewhere else, anywhere. Keep moving.
+</p>
+
+<p>
+</p>
+
+<p>This one I goofed — too much for one row of buildings, too little for the row beyond it; I found myself coming down on a roof. But not a nice flat one where I might have tarried three seconds to launch another peewee A-rocket; this roof was a jungle of pipes and stanchions and assorted ironmongery — a factory maybe, or some sort of chemical works. No place to land. Worse still, half a dozen natives were up there. These geezers are humanoid, eight or nine feet tall, much skinnier than we are and with a higher body temperature; they don't wear any clothes and they stand out in a set of snoopers like a neon sign. They look still funnier in daylight with your bare eyes but I would rather fight them than the arachnids — those Bugs make me queezy.
+</p>
+
+<p>
+If these laddies were up there thirty seconds earlier when my rocket hit, then they couldn't see me, or anything. But I couldn't be certain and didn't want to tangle with them in any case; it wasn't that kind of a raid. So I jumped again while I was still in the air, scattering a handful of ten-second fire pills to keep
+them busy, grounded, jumped again at once, and called out, "Second section! Even numbers!...Advance!" and kept right on going to close the gap, while trying to spot, every time I jumped, something worth expending a rocket on. I had three more of the little A-rockets and I certainly didn't intend to take any back with me.
+</p>
+
+<p>
+But I had had pounded into me that you must get your money's worth with atomic weapons — it was only the second time that I had been allowed to carry them. Right now I was trying to spot their waterworks; a direct hit on it could make the whole city uninhabitable, force them to evacuate it without directly killing anyone — just the sort of nuisance we had been sent down to commit. It should — according to the map we had studied under hypnosis — be about three miles upstream from where I was.
+</p>
+
+<p>
+But I couldn't see it; my jumps didn't take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+Fourth and Fifth squads answered, "Wilco"; Ace said, "We're already doin' it — pick up your feet." Red's beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+<p>
+At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I'm no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn't already been told to jump, I guess I wouldn't have got out of there.
+</p>
+
+<p>
+Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+<p>
+There was something on the horizon in the direction of their spaceport — administration & control, maybe, or possibly even a starship. Almost in line and about half as far away was an enormous structure which I couldn't identify even that loosely. The range to the spaceport was extreme but I let the rocket see it, said, "Go find it, baby!" and twisted its tail — slapped the last one in, sent it toward the nearer target, and jumped. That building took a direct hit just as I left it. Either a skinny had judged (correctly) that it was worth one of their buildings to try for one of us, or one of my own mates was getting mighty careless with fireworks. Either way, I didn't want to jump from that spot, even a skimmer; I decided to go through the next couple of buildings instead of over. So I grabbed the heavy flamer off my back as I hit and dipped the snoopers down over my eyes, tackled a wall in front of me with a knife beam at full power. A section of
+wall fell away and I charged in. And backed out even faster. I didn't know what it was I had cracked open. A congregation in church — a skinny flophouse —
+maybe even their defense headquarters. All I knew was that it was a very big room filled with more skinnies than I wanted to see in my whole life.
+</p>
+
+</body>
+
+</html>
\ No newline at end of file
diff --git a/src/cachingpolicy/htdocs/index_big.html b/src/cachingpolicy/htdocs/index_big.html
new file mode 100644
index 0000000..ba35a87
--- /dev/null
+++ b/src/cachingpolicy/htdocs/index_big.html
@@ -0,0 +1,709 @@
+<html>
+
+<body>
+
+<p>
+	A long text page. Here is some text:
+</p>
+
+<p>
+Then suddenly nothing. Nothing at all. No sound, no pressure, no weight. Floating in darkness... free fall, maybe thirty miles up, above the effective atmosphere, falling weightlessly toward the surface of a planet you've never seen. But I'm not shaking now; it's the wait beforehand that wears. Once you unload, you can't get hurt — because if anything goes wrong it will happen so fast that you'll buy it without noticing that you're dead, hardly.
+</p>
+
+<p>
+Almost at once I felt the capsule twist and sway, then steady down so that my weight was on my back...weight that built up quickly until I was at my full weight (0.87 gee, we had been told) for that planet as the capsule reached terminal velocity for the thin upper atmosphere. A pilot who is a real artist (and the Captain was) will approach and brake so that your launching speed as you shoot out of the tube places you just dead in space relative to the rotational speed of the planet at that latitude. The loaded capsules are heavy; they punch through the high, thin winds of the upper atmosphere without being blown too far out of position — but just the same a platoon is bound to disperse on the way down, lose some of the perfect formation in which it unloads. A sloppy pilot can make this still worse, scatter a strike group over so much terrain that it can't make rendezvous for retrieval, much less carry out its mission. An infantryman can fight only if somebody else delivers him to his zone; in a way I suppose pilots are just as essential as we are.
+</p>
+
+<p>
+I could tell from the gentle way my capsule entered the atmosphere that the Captain had laid us down with as near zero lateral vector as you could ask for. I felt happy — not only a tight formation when we hit and no time wasted, but also a pilot who puts you down properly is a pilot who is smart and precise on retrieval.
+</p>
+
+<p>
+The outer shell burned away and sloughed off — unevenly, for I tumbled. Then the rest of it went and I straightened out. The turbulence brakes of the second shell bit in and the ride got rough... and still rougher as they burned off one at a time and the second shell began to go to pieces. One of the things that helps a capsule trooper to live long enough to draw a pension is that the skins peeling off his capsule not only slow him down, they also fill the sky over the target area with so much junk that radar picks up reflections from dozens of targets for each man in the drop, any one of which could be a man, or a bomb, or anything. It's enough to give a ballistic computer nervous breakdowns — and does. To add to the fun your ship lays a series of dummy eggs in the seconds immediately following your drop, dummies that will fall faster because they don't slough. They get under you, explode, throw out "window," even operate as transponders, rocket sideways, and do other things to add to the confusion of your reception committee on the ground.
+</p>
+
+<p>
+In the meantime your ship is locked firmly on the directional beacon of your platoon leader, ignoring the radar "noise" it has created and following you in, computing your impact for future use. When the second shell was gone, the third shell automatically opened my first ribbon chute. It didn't last long but it wasn't expected to; one good, hard jerk at several gee and it went its way and I went mine. The second chute lasted a little bit longer and the third chute lasted quite a while; it began to be rather too warm inside the capsule and I started thinking about landing.
+</p>
+
+<p>
+The third shell peeled off when its last chute was gone and now I had nothing around me but my suit armor and a plastic egg. I was still strapped inside it, unable to move; it was time to decide how and where I was going to ground. Without moving my arms (I couldn't) I thumbed the switch for a proximity reading and read it when it flashed on in the instrument reflector inside my helmet in front of my forehead. A mile and eight-tenths — A little closer than I liked, especially without company. The inner egg had reached steady speed, no more help to be gained by staying inside it, and its skin temperature indicated that it would not open automatically for a while yet — so I flipped a switch with my other thumb and got rid of it.
+</p>
+
+<p>
+The first charge cut all the straps; the second charge exploded the plastic egg away from me in eight separate pieces — and I was outdoors, sitting on air, and could see! Better still, the eight discarded pieces were metal-coated (except for the small bit I had taken proximity reading through) and would give back the same reflection as an armored man. Any radar viewer, alive or cybernetic, would now have a sad time sorting me out from the junk nearest me, not to mention the thousands of other bits and pieces for miles on each side, above, and below me. Part of a mobile infantryman's training is to let him see, from the ground and both by eye and by radar, just how confusing a drop is to the forces on the ground — because you feel awful naked up there. It is easy to panic and either open a chute too soon and become a sitting duck (do ducks really sit? — if so, why?) or fail to open it and break your ankles, likewise backbone and skull. So I stretched, getting the kinks out, and looked around... then doubled up again and straightened out in a swan dive face down and took a good look. It was night down there, as planned, but infrared snoopers let you size up terrain quite well after you are used to them. The river that cut diagonally through the city was almost below me and coming up fast, shining out clearly with a higher temperature than the land. I didn't care which side of it I landed on but I didn't want to land in it; it would slow me down.
+</p>
+
+<p>
+I noticed a dash off to the right at about my altitude; some unfriendly native down below had burned what was probably a piece of my egg. So I fired my first chute at once, intending if possible to jerk myself right off his screen as he followed the targets down in closing range. I braced for the shock, rode it, then floated down for about twenty seconds before unloading the chute — not wishing to call attention to myself in still another way by not falling at the speed of the other stuff around me. It must have worked; I wasn't burned.
+</p>
+
+<p>
+About six hundred feet up I shot the second chute... saw very quickly that I was being carried over into the river, found that I was going to pass about a hundred feet up over a flat-roofed warehouse or some such by the river... blew the chute free and came in for a good enough if rather bouncy landing on the roof by means of the suit's jump jets. I was scanning for Sergeant Jelal's beacon as I hit. And found that I was on the wrong side of the river; Jelly's star showed up on the compass ring inside my helmet far south of where it should have been — I was too far north. I trotted toward the river side of the roof as I took a range and bearing on the squad leader next to me, found that he was over a mile out of position, called, "Ace! dress your line," tossed a bomb behind me as I stepped off the building and across the river. Ace answered as I could have expected — Ace should have had my spot but he didn't want to give up his squad; nevertheless he didn't fancy taking orders from me.
+</p>
+
+<p>
+The warehouse went up behind me and the blast hit me while I was still over the river, instead of being shielded by the buildings on the far side as I should have been. It darn near tumbled my gyros and I came close to tumbling myself. I had set that bomb for fifteen seconds... or had I? I suddenly realized that I had let myself get excited, the worst thing you can do once you're on the ground. "Just like a drill," that was the way, just as Jelly had warned me. Take your time and do it right, even if it takes another half second. As I hit I took another reading on Ace and told him again to realign his squad. He didn't answer but he was already doing it. I let it ride. As long as Ace did his job, I could afford to swallow his surliness — for now. But back aboard ship (if Jelly kept me on as assistant section leader) we would eventually have to pick a quiet spot and find out who was boss. He was a career corporal and I was just a term lance acting as corporal, but he was under me and you can't afford to take any lip under those circumstances. Not permanently.
+</p>
+
+<p>
+But I didn't have time then to think about it; while I was jumping the river I had spotted a juicy target and I wanted to get it before somebody else noticed it — a lovely big group of what looked like public buildings on a hill. Temples, maybe... or a palace. They were miles outside the area we were sweeping, but one rule of a smash & run is to expend at least half your ammo outside your sweep area; that way the enemy is kept confused as to where you actually are — that and keep moving, do everything fast. You're always heavily outnumbered; surprise and speed are what saves you. I was already loading my rocket launcher while I was checking on Ace and telling him for the second time to straighten up. Jelly's voice reached me right on top of that on the all-hands circuit: "Platoon! By leapfrog! Forward!" My boss, Sergeant Johnson, echoed, "By leapfrog! Odd numbers! Advance!" That left me with nothing to worry about for twenty seconds, so I jumped up on the building nearest me, raised the launcher to my shoulder, found the target and pulled the first trigger to let the rocket have a look at its target — pulled the second trigger and kissed it on its way, jumped back to the ground. "Second section, even numbers!" I called out... waited for the count in my mind and ordered, "Advance!"
+</p>
+
+<p>
+And did so myself, hopping over the next row of buildings, and, while I was in the air, fanning the first row by the river front with a hand flamer. They seemed to be wood construction and it looked like time to start a good fire — with luck, some of those warehouses would house oil products, or even explosives. As I hit, the Y-rack on my shoulders launched two small H. E. bombs a couple of hundred yards each way to my right and left flanks but I never saw what they did as just then my first rocket hit — that unmistakable (if you've ever seen one) brilliance of an atomic explosion. It was just a peewee, of course, less than two kilotons nominal yield, with tamper and implosion squeeze to produce results from a less-than-critical mass — but then who wants to be bunk mates with a cosmic catastrophe? It was enough to clean off that hilltop and make everybody in the city take shelter against fallout. Better still, any of the local yokels who happened to be outdoors and looking that way wouldn't be seeing anything else for a couple of hours — meaning me. The dash hadn't dazzled me, nor would it dazzle any of us; our face bowls are heavily leaded, we wear snoopers over our eyes — and we're trained to duck and take it on the armor if we do happen to be looking the wrong way.
+</p>
+
+<p>
+So I merely blinked hard — opened my eyes and stared straight at a local citizen just coming out of an opening in the building ahead of me. He looked at me, I looked at him, and he started to raise something — a weapon, I suppose — as Jelly called out, "Odd numbers! Advance!"
+</p>
+
+<p>
+I didn't have time to fool with him; I was a good five hundred yards short of where I should have been by then. I still had the hand flamer in my left hand; I toasted him and jumped over the building he had been coming out of, as I started to count. A hand flamer is primarily for incendiary work but it is a good defensive anti-personnel weapon in tight quarters; you don't have to aim it much.
+</p>
+
+<p>
+Between excitement and anxiety to catch up I jumped too high and too wide. It's always a temptation to get the most out of your jump gear — but don't do it! It leaves you hanging in the air for seconds, a big fat target. The way to advance is to skim over each building as you come to it, barely clearing it, and taking full advantage of cover while you're down — and never stay in one place more than a second or two, never give them time to target in on you. Be somewhere else, anywhere. Keep moving.
+</p>
+
+<p>
+</p>
+
+<p>This one I goofed — too much for one row of buildings, too little for the row beyond it; I found myself coming down on a roof. But not a nice flat one where I might have tarried three seconds to launch another peewee A-rocket; this roof was a jungle of pipes and stanchions and assorted ironmongery — a factory maybe, or some sort of chemical works. No place to land. Worse still, half a dozen natives were up there. These geezers are humanoid, eight or nine feet tall, much skinnier than we are and with a higher body temperature; they don't wear any clothes and they stand out in a set of snoopers like a neon sign. They look still funnier in daylight with your bare eyes but I would rather fight them than the arachnids — those Bugs make me queezy.
+</p>
+
+<p>
+If these laddies were up there thirty seconds earlier when my rocket hit, then they couldn't see me, or anything. But I couldn't be certain and didn't want to tangle with them in any case; it wasn't that kind of a raid. So I jumped again while I was still in the air, scattering a handful of ten-second fire pills to keep
+them busy, grounded, jumped again at once, and called out, "Second section! Even numbers!...Advance!" and kept right on going to close the gap, while trying to spot, every time I jumped, something worth expending a rocket on. I had three more of the little A-rockets and I certainly didn't intend to take any back with me.
+</p>
+
+<p>
+But I had had pounded into me that you must get your money's worth with atomic weapons — it was only the second time that I had been allowed to carry them. Right now I was trying to spot their waterworks; a direct hit on it could make the whole city uninhabitable, force them to evacuate it without directly killing anyone — just the sort of nuisance we had been sent down to commit. It should — according to the map we had studied under hypnosis — be about three miles upstream from where I was.
+</p>
+
+<p>
+But I couldn't see it; my jumps didn't take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+Fourth and Fifth squads answered, "Wilco"; Ace said, "We're already doin' it — pick up your feet." Red's beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+<p>
+At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I'm no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn't already been told to jump, I guess I wouldn't have got out of there.
+</p>
+
+<p>
+Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+<p>
+There was something on the horizon in the direction of their spaceport — administration & control, maybe, or possibly even a starship. Almost in line and about half as far away was an enormous structure which I couldn't identify even that loosely. The range to the spaceport was extreme but I let the rocket see it, said, "Go find it, baby!" and twisted its tail — slapped the last one in, sent it toward the nearer target, and jumped. That building took a direct hit just as I left it. Either a skinny had judged (correctly) that it was worth one of their buildings to try for one of us, or one of my own mates was getting mighty careless with fireworks. Either way, I didn't want to jump from that spot, even a skimmer; I decided to go through the next couple of buildings instead of over. So I grabbed the heavy flamer off my back as I hit and dipped the snoopers down over my eyes, tackled a wall in front of me with a knife beam at full power. A section of
+wall fell away and I charged in. And backed out even faster. I didn't know what it was I had cracked open. A congregation in church — a skinny flophouse —
+maybe even their defense headquarters. All I knew was that it was a very big room filled with more skinnies than I wanted to see in my whole life.
+</p>
+
+<p>
+Probably not a church, for somebody took a shot at me as I popped back out just a slug that bounced off my armor, made my ears ring, and staggered me without hurting me. But it reminded me that I wasn't supposed to leave without giving them a souvenir of my visit. I grabbed the first thing on my belt and lobbed it in — and heard it start to squawk. As they keep telling you in Basic, doing something constructive at once is better than figuring out the best thing to do hours later. By sheer chance I had done the right thing. This was a special bomb, one each issued to us for this mission with instructions to use them if we found ways to make them effective. The squawking I heard as I threw it was the bomb shouting in skinny talk (free translation): "I'm a thirty-second bomb! I'm a thirty-second bomb! Twenty-nine!... twenty-eight!... twenty-seven! — "It was supposed to frazzle their nerves. Maybe it did; it certainly frazzled mine. Kinder to shoot a man. I didn't wait for the countdown; I jumped, while I wondered whether they would find enough doors and windows to swarm out in time.
+</p>
+
+<p>
+I got a bearing on Red's blinker at the top of the jump and one on Ace as I grounded. I was falling behind again — time to hurry. But three minutes later we had closed the gap; I had Red on my left flank a half mile away. He reported it to Jelly. We heard Jelly's relaxed growl to the entire platoon: "Circle is closed, but the beacon is not down yet. Move forward slowly and mill around, make a little more trouble — but mind the lad on each side of you; don't make trouble for him. Good job, so far — don't spoil it. Platoon! By sections...Muster!"
+</p>
+
+<p>
+It looked like a good job to me, too; much of the city was burning and, although it was almost full light now, it was hard to tell whether bare eyes were better than snoopers, the smoke was so thick. Johnson, our section leader, sounded off: "Second section, call off!" I echoed, "Squads four, five, and six — call off and report!" The assortment of safe circuits we had available in the new model comm units certainly speeded things up; Jelly could talk to anybody or to his section leaders; a section leader could call his whole section, or his non-coms; and the platoon could muster twice as fast, when seconds matter. I listened to the fourth squad call off while I inventoried my remaining firepower and lobbed one bomb toward a skinny who poked his head around a corner. He left and so did I — "Mill around," the boss man had said.
+</p>
+
+<p>
+The fourth squad bumbled the call off until the squad leader remembered to fill in with Jenkins' number; the fifth squad clicked off like an abacus and I began to feel good . . . when the call off stopped after number four in Ace's squad. I called out, "Ace, where's Dizzy?"
+</p>
+
+<p>
+"Shut up," he said. "Number six! Call off!"
+</p>
+
+<p>
+"Six!" Smith answered.
+</p>
+
+<p>
+"Seven!"
+</p>
+
+<p>
+"Sixth squad, Flores missing," Ace completed it. "Squad leader out for pickup."
+</p>
+
+<p>
+"One man absent," I reported to Johnson. "Flores, squad six."
+</p>
+
+<p>
+"Missing or dead?"
+</p>
+
+<p>
+"I don't know. Squad leader and assistant section leader dropping out for pickup."
+</p>
+
+<p>
+"Johnnie, you let Ace take it."
+</p>
+
+<p>
+But I didn't hear him, so I didn't answer. I heard him report to Jelly and I heard Jelly cuss. Now look, I wasn't bucking for a medal — it's the assistant section leader's business to make pickup; he's the chaser, the last man in, expendable. The squad leaders have other work to do. As you've no doubt gathered by now the assistant section leader isn't necessary as long as the section leader is alive. Right that moment I was feeling unusually expendable, almost expended, because I was hearing the sweetest sound in the universe, the beacon the retrieval boat would land on, sounding our recall. The beacon is a robot rocket, fired ahead of the retrieval boat, just a spike that buries itself in the ground and starts broadcasting that welcome, welcome music. The retrieval boat homes in on it automatically three minutes later and you had better be on hand, because the bus can't wait and there won't be another one along.
+</p>
+
+<p>
+But you don't walk away on another cap trooper, not while there's a chance he's still alive — not in Rasczak's Roughnecks. Not in any outfit of the Mobile Infantry. You try to make pickup. I heard Jelly order: "Heads up, lads! Close to retrieval circle and interdict! On the bounce!"
+</p>
+
+<p>
+And I heard the beacon's sweet voice: " — to the everlasting glory of the infantry, shines the name, shines the name of Rodger Young!" and I wanted to head for it so bad I could taste it.
+</p>
+
+<p>
+Instead I was headed the other way, closing on Ace's beacon and expending what I had left of bombs and fire pills and anything else that would weigh me down. "Ace! You got his beacon?"
+</p>
+
+<p>
+"Yes. Go back, Useless!"
+</p>
+
+<p>
+"I've got you by eye now. Where is he?"
+</p>
+
+<p>
+"Right ahead of me, maybe quarter mile. Scram! He's my man ."
+</p>
+
+<p>
+I didn't answer; I simply cut left oblique to reach Ace about where he said Dizzy was.
+</p>
+
+<p>
+And found Ace standing over him, a couple of skinnies flamed down and more running away. I lit beside him. "Let's get him out of his armor — the boat'll be down any second!"
+</p>
+
+<p>
+"He's too bad hurt!"
+</p>
+
+<p>
+I looked and saw that it was true — there was actually a hole in his armor and blood coming out. And I was stumped. To make a wounded pickup you get him out of his armor... then you simply pick him up in your arms — no trouble in a powered suit — and bounce away from there. A bare man weighs less than the ammo and stuff you've expended. "What'll we do?"
+</p>
+
+<p>
+"We carry him," Ace said grimly. "Grab ahold the left side of his belt." He grabbed the right side, we manhandled Flores to his feet. "Lock on! Now... by the numbers, stand by to jump — one — two!"
+</p>
+
+<p>
+We jumped. Not far, not well. One man alone couldn't have gotten him off the ground; an armored suit is too heavy. But split it between two men and it can be done.
+We jumped — and we jumped — and again, and again, with Ace calling it and both of us steadying and catching Dizzy on each grounding. His gyros seemed to be out.
+</p>
+
+<p>
+We heard the beacon cut off as the retrieval boat landed on it — I saw it land . . . and it was too far away. We heard the acting platoon sergeant call out: "In succession, prepare to embark!"
+</p>
+
+<p>
+And Jelly called out, "Belay that order!"
+</p>
+
+<p>
+We broke at last into the open and saw the boat standing on its tail, heard the ululation of its take-off warning — saw the platoon still on the ground around it, in interdiction circle, crouching behind the shield they had formed. Heard Jelly shout, "In succession, man the boat — move!"
+</p>
+
+<p>
+And we were still too far away! I could see them peel off from the first squad, swarm into the boat as the interdiction circle tightened. And a single figure broke out of the circle, came toward us at a speed possible only to a command suit. Jelly caught us while we were in the air, grabbed Flores by his Y-rack and helped us lift. Three jumps got us to the boat. Everybody else was inside but the door was still open. We got him in and closed it while the boat pilot screamed that we had made her miss rendezvous and now we had all bought it! Jelly paid no attention to her; we laid Flores down and lay down beside him. As the blast hit us Jelly was saying to himself, "All present, Lieutenant. Three men hurt — but all present!"
+</p>
+
+<p>
+I'll say this for Captain Deladrier: they don't make any better pilots. A rendezvous, boat to ship in orbit, is precisely calculated. I don't know how, but it is, and you don't change it. You can't.
+</p>
+
+<p>
+Only she did. She saw in her scope that the boat had failed to blast on time; she braked back, picked up speed again — and matched and took us in, just by eye and touch, no time to compute it. If the Almighty ever needs an assistant to keep the stars in their courses, I know where he can look.
+</p>
+
+<p>
+Flores died on the way up.
+</p>
+
+<p>
+ -- repeat --
+</p>
+
+<p>
+Then suddenly nothing. Nothing at all. No sound, no pressure, no weight. Floating in darkness... free fall, maybe thirty miles up, above the effective atmosphere, falling weightlessly toward the surface of a planet you've never seen. But I'm not shaking now; it's the wait beforehand that wears. Once you unload, you can't get hurt — because if anything goes wrong it will happen so fast that you'll buy it without noticing that you're dead, hardly.
+</p>
+
+<p>
+Almost at once I felt the capsule twist and sway, then steady down so that my weight was on my back...weight that built up quickly until I was at my full weight (0.87 gee, we had been told) for that planet as the capsule reached terminal velocity for the thin upper atmosphere. A pilot who is a real artist (and the Captain was) will approach and brake so that your launching speed as you shoot out of the tube places you just dead in space relative to the rotational speed of the planet at that latitude. The loaded capsules are heavy; they punch through the high, thin winds of the upper atmosphere without being blown too far out of position — but just the same a platoon is bound to disperse on the way down, lose some of the perfect formation in which it unloads. A sloppy pilot can make this still worse, scatter a strike group over so much terrain that it can't make rendezvous for retrieval, much less carry out its mission. An infantryman can fight only if somebody else delivers him to his zone; in a way I suppose pilots are just as essential as we are.
+</p>
+
+<p>
+I could tell from the gentle way my capsule entered the atmosphere that the Captain had laid us down with as near zero lateral vector as you could ask for. I felt happy — not only a tight formation when we hit and no time wasted, but also a pilot who puts you down properly is a pilot who is smart and precise on retrieval.
+</p>
+
+<p>
+The outer shell burned away and sloughed off — unevenly, for I tumbled. Then the rest of it went and I straightened out. The turbulence brakes of the second shell bit in and the ride got rough... and still rougher as they burned off one at a time and the second shell began to go to pieces. One of the things that helps a capsule trooper to live long enough to draw a pension is that the skins peeling off his capsule not only slow him down, they also fill the sky over the target area with so much junk that radar picks up reflections from dozens of targets for each man in the drop, any one of which could be a man, or a bomb, or anything. It's enough to give a ballistic computer nervous breakdowns — and does. To add to the fun your ship lays a series of dummy eggs in the seconds immediately following your drop, dummies that will fall faster because they don't slough. They get under you, explode, throw out "window," even operate as transponders, rocket sideways, and do other things to add to the confusion of your reception committee on the ground.
+</p>
+
+<p>
+In the meantime your ship is locked firmly on the directional beacon of your platoon leader, ignoring the radar "noise" it has created and following you in, computing your impact for future use. When the second shell was gone, the third shell automatically opened my first ribbon chute. It didn't last long but it wasn't expected to; one good, hard jerk at several gee and it went its way and I went mine. The second chute lasted a little bit longer and the third chute lasted quite a while; it began to be rather too warm inside the capsule and I started thinking about landing.
+</p>
+
+<p>
+The third shell peeled off when its last chute was gone and now I had nothing around me but my suit armor and a plastic egg. I was still strapped inside it, unable to move; it was time to decide how and where I was going to ground. Without moving my arms (I couldn't) I thumbed the switch for a proximity reading and read it when it flashed on in the instrument reflector inside my helmet in front of my forehead. A mile and eight-tenths — A little closer than I liked, especially without company. The inner egg had reached steady speed, no more help to be gained by staying inside it, and its skin temperature indicated that it would not open automatically for a while yet — so I flipped a switch with my other thumb and got rid of it.
+</p>
+
+<p>
+The first charge cut all the straps; the second charge exploded the plastic egg away from me in eight separate pieces — and I was outdoors, sitting on air, and could see! Better still, the eight discarded pieces were metal-coated (except for the small bit I had taken proximity reading through) and would give back the same reflection as an armored man. Any radar viewer, alive or cybernetic, would now have a sad time sorting me out from the junk nearest me, not to mention the thousands of other bits and pieces for miles on each side, above, and below me. Part of a mobile infantryman's training is to let him see, from the ground and both by eye and by radar, just how confusing a drop is to the forces on the ground — because you feel awful naked up there. It is easy to panic and either open a chute too soon and become a sitting duck (do ducks really sit? — if so, why?) or fail to open it and break your ankles, likewise backbone and skull. So I stretched, getting the kinks out, and looked around... then doubled up again and straightened out in a swan dive face down and took a good look. It was night down there, as planned, but infrared snoopers let you size up terrain quite well after you are used to them. The river that cut diagonally through the city was almost below me and coming up fast, shining out clearly with a higher temperature than the land. I didn't care which side of it I landed on but I didn't want to land in it; it would slow me down.
+</p>
+
+<p>
+I noticed a dash off to the right at about my altitude; some unfriendly native down below had burned what was probably a piece of my egg. So I fired my first chute at once, intending if possible to jerk myself right off his screen as he followed the targets down in closing range. I braced for the shock, rode it, then floated down for about twenty seconds before unloading the chute — not wishing to call attention to myself in still another way by not falling at the speed of the other stuff around me. It must have worked; I wasn't burned.
+</p>
+
+<p>
+About six hundred feet up I shot the second chute... saw very quickly that I was being carried over into the river, found that I was going to pass about a hundred feet up over a flat-roofed warehouse or some such by the river... blew the chute free and came in for a good enough if rather bouncy landing on the roof by means of the suit's jump jets. I was scanning for Sergeant Jelal's beacon as I hit. And found that I was on the wrong side of the river; Jelly's star showed up on the compass ring inside my helmet far south of where it should have been — I was too far north. I trotted toward the river side of the roof as I took a range and bearing on the squad leader next to me, found that he was over a mile out of position, called, "Ace! dress your line," tossed a bomb behind me as I stepped off the building and across the river. Ace answered as I could have expected — Ace should have had my spot but he didn't want to give up his squad; nevertheless he didn't fancy taking orders from me.
+</p>
+
+<p>
+The warehouse went up behind me and the blast hit me while I was still over the river, instead of being shielded by the buildings on the far side as I should have been. It darn near tumbled my gyros and I came close to tumbling myself. I had set that bomb for fifteen seconds... or had I? I suddenly realized that I had let myself get excited, the worst thing you can do once you're on the ground. "Just like a drill," that was the way, just as Jelly had warned me. Take your time and do it right, even if it takes another half second. As I hit I took another reading on Ace and told him again to realign his squad. He didn't answer but he was already doing it. I let it ride. As long as Ace did his job, I could afford to swallow his surliness — for now. But back aboard ship (if Jelly kept me on as assistant section leader) we would eventually have to pick a quiet spot and find out who was boss. He was a career corporal and I was just a term lance acting as corporal, but he was under me and you can't afford to take any lip under those circumstances. Not permanently.
+</p>
+
+<p>
+But I didn't have time then to think about it; while I was jumping the river I had spotted a juicy target and I wanted to get it before somebody else noticed it — a lovely big group of what looked like public buildings on a hill. Temples, maybe... or a palace. They were miles outside the area we were sweeping, but one rule of a smash & run is to expend at least half your ammo outside your sweep area; that way the enemy is kept confused as to where you actually are — that and keep moving, do everything fast. You're always heavily outnumbered; surprise and speed are what saves you. I was already loading my rocket launcher while I was checking on Ace and telling him for the second time to straighten up. Jelly's voice reached me right on top of that on the all-hands circuit: "Platoon! By leapfrog! Forward!" My boss, Sergeant Johnson, echoed, "By leapfrog! Odd numbers! Advance!" That left me with nothing to worry about for twenty seconds, so I jumped up on the building nearest me, raised the launcher to my shoulder, found the target and pulled the first trigger to let the rocket have a look at its target — pulled the second trigger and kissed it on its way, jumped back to the ground. "Second section, even numbers!" I called out... waited for the count in my mind and ordered, "Advance!"
+</p>
+
+<p>
+And did so myself, hopping over the next row of buildings, and, while I was in the air, fanning the first row by the river front with a hand flamer. They seemed to be wood construction and it looked like time to start a good fire — with luck, some of those warehouses would house oil products, or even explosives. As I hit, the Y-rack on my shoulders launched two small H. E. bombs a couple of hundred yards each way to my right and left flanks but I never saw what they did as just then my first rocket hit — that unmistakable (if you've ever seen one) brilliance of an atomic explosion. It was just a peewee, of course, less than two kilotons nominal yield, with tamper and implosion squeeze to produce results from a less-than-critical mass — but then who wants to be bunk mates with a cosmic catastrophe? It was enough to clean off that hilltop and make everybody in the city take shelter against fallout. Better still, any of the local yokels who happened to be outdoors and looking that way wouldn't be seeing anything else for a couple of hours — meaning me. The dash hadn't dazzled me, nor would it dazzle any of us; our face bowls are heavily leaded, we wear snoopers over our eyes — and we're trained to duck and take it on the armor if we do happen to be looking the wrong way.
+</p>
+
+<p>
+So I merely blinked hard — opened my eyes and stared straight at a local citizen just coming out of an opening in the building ahead of me. He looked at me, I looked at him, and he started to raise something — a weapon, I suppose — as Jelly called out, "Odd numbers! Advance!"
+</p>
+
+<p>
+I didn't have time to fool with him; I was a good five hundred yards short of where I should have been by then. I still had the hand flamer in my left hand; I toasted him and jumped over the building he had been coming out of, as I started to count. A hand flamer is primarily for incendiary work but it is a good defensive anti-personnel weapon in tight quarters; you don't have to aim it much.
+</p>
+
+<p>
+Between excitement and anxiety to catch up I jumped too high and too wide. It's always a temptation to get the most out of your jump gear — but don't do it! It leaves you hanging in the air for seconds, a big fat target. The way to advance is to skim over each building as you come to it, barely clearing it, and taking full advantage of cover while you're down — and never stay in one place more than a second or two, never give them time to target in on you. Be somewhere else, anywhere. Keep moving.
+</p>
+
+<p>
+</p>
+
+<p>This one I goofed — too much for one row of buildings, too little for the row beyond it; I found myself coming down on a roof. But not a nice flat one where I might have tarried three seconds to launch another peewee A-rocket; this roof was a jungle of pipes and stanchions and assorted ironmongery — a factory maybe, or some sort of chemical works. No place to land. Worse still, half a dozen natives were up there. These geezers are humanoid, eight or nine feet tall, much skinnier than we are and with a higher body temperature; they don't wear any clothes and they stand out in a set of snoopers like a neon sign. They look still funnier in daylight with your bare eyes but I would rather fight them than the arachnids — those Bugs make me queezy.
+</p>
+
+<p>
+If these laddies were up there thirty seconds earlier when my rocket hit, then they couldn't see me, or anything. But I couldn't be certain and didn't want to tangle with them in any case; it wasn't that kind of a raid. So I jumped again while I was still in the air, scattering a handful of ten-second fire pills to keep
+them busy, grounded, jumped again at once, and called out, "Second section! Even numbers!...Advance!" and kept right on going to close the gap, while trying to spot, every time I jumped, something worth expending a rocket on. I had three more of the little A-rockets and I certainly didn't intend to take any back with me.
+</p>
+
+<p>
+But I had had pounded into me that you must get your money's worth with atomic weapons — it was only the second time that I had been allowed to carry them. Right now I was trying to spot their waterworks; a direct hit on it could make the whole city uninhabitable, force them to evacuate it without directly killing anyone — just the sort of nuisance we had been sent down to commit. It should — according to the map we had studied under hypnosis — be about three miles upstream from where I was.
+</p>
+
+<p>
+But I couldn't see it; my jumps didn't take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+Fourth and Fifth squads answered, "Wilco"; Ace said, "We're already doin' it — pick up your feet." Red's beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+<p>
+At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I'm no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn't already been told to jump, I guess I wouldn't have got out of there.
+</p>
+
+<p>
+Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+<p>
+There was something on the horizon in the direction of their spaceport — administration & control, maybe, or possibly even a starship. Almost in line and about half as far away was an enormous structure which I couldn't identify even that loosely. The range to the spaceport was extreme but I let the rocket see it, said, "Go find it, baby!" and twisted its tail — slapped the last one in, sent it toward the nearer target, and jumped. That building took a direct hit just as I left it. Either a skinny had judged (correctly) that it was worth one of their buildings to try for one of us, or one of my own mates was getting mighty careless with fireworks. Either way, I didn't want to jump from that spot, even a skimmer; I decided to go through the next couple of buildings instead of over. So I grabbed the heavy flamer off my back as I hit and dipped the snoopers down over my eyes, tackled a wall in front of me with a knife beam at full power. A section of
+wall fell away and I charged in. And backed out even faster. I didn't know what it was I had cracked open. A congregation in church — a skinny flophouse —
+maybe even their defense headquarters. All I knew was that it was a very big room filled with more skinnies than I wanted to see in my whole life.
+</p>
+
+<p>
+Probably not a church, for somebody took a shot at me as I popped back out just a slug that bounced off my armor, made my ears ring, and staggered me without hurting me. But it reminded me that I wasn't supposed to leave without giving them a souvenir of my visit. I grabbed the first thing on my belt and lobbed it in — and heard it start to squawk. As they keep telling you in Basic, doing something constructive at once is better than figuring out the best thing to do hours later. By sheer chance I had done the right thing. This was a special bomb, one each issued to us for this mission with instructions to use them if we found ways to make them effective. The squawking I heard as I threw it was the bomb shouting in skinny talk (free translation): "I'm a thirty-second bomb! I'm a thirty-second bomb! Twenty-nine!... twenty-eight!... twenty-seven! — "It was supposed to frazzle their nerves. Maybe it did; it certainly frazzled mine. Kinder to shoot a man. I didn't wait for the countdown; I jumped, while I wondered whether they would find enough doors and windows to swarm out in time.
+</p>
+
+<p>
+I got a bearing on Red's blinker at the top of the jump and one on Ace as I grounded. I was falling behind again — time to hurry. But three minutes later we had closed the gap; I had Red on my left flank a half mile away. He reported it to Jelly. We heard Jelly's relaxed growl to the entire platoon: "Circle is closed, but the beacon is not down yet. Move forward slowly and mill around, make a little more trouble — but mind the lad on each side of you; don't make trouble for him. Good job, so far — don't spoil it. Platoon! By sections...Muster!"
+</p>
+
+<p>
+It looked like a good job to me, too; much of the city was burning and, although it was almost full light now, it was hard to tell whether bare eyes were better than snoopers, the smoke was so thick. Johnson, our section leader, sounded off: "Second section, call off!" I echoed, "Squads four, five, and six — call off and report!" The assortment of safe circuits we had available in the new model comm units certainly speeded things up; Jelly could talk to anybody or to his section leaders; a section leader could call his whole section, or his non-coms; and the platoon could muster twice as fast, when seconds matter. I listened to the fourth squad call off while I inventoried my remaining firepower and lobbed one bomb toward a skinny who poked his head around a corner. He left and so did I — "Mill around," the boss man had said.
+</p>
+
+<p>
+The fourth squad bumbled the call off until the squad leader remembered to fill in with Jenkins' number; the fifth squad clicked off like an abacus and I began to feel good . . . when the call off stopped after number four in Ace's squad. I called out, "Ace, where's Dizzy?"
+</p>
+
+<p>
+"Shut up," he said. "Number six! Call off!"
+</p>
+
+<p>
+"Six!" Smith answered.
+</p>
+
+<p>
+"Seven!"
+</p>
+
+<p>
+"Sixth squad, Flores missing," Ace completed it. "Squad leader out for pickup."
+</p>
+
+<p>
+"One man absent," I reported to Johnson. "Flores, squad six."
+</p>
+
+<p>
+"Missing or dead?"
+</p>
+
+<p>
+"I don't know. Squad leader and assistant section leader dropping out for pickup."
+</p>
+
+<p>
+"Johnnie, you let Ace take it."
+</p>
+
+<p>
+But I didn't hear him, so I didn't answer. I heard him report to Jelly and I heard Jelly cuss. Now look, I wasn't bucking for a medal — it's the assistant section leader's business to make pickup; he's the chaser, the last man in, expendable. The squad leaders have other work to do. As you've no doubt gathered by now the assistant section leader isn't necessary as long as the section leader is alive. Right that moment I was feeling unusually expendable, almost expended, because I was hearing the sweetest sound in the universe, the beacon the retrieval boat would land on, sounding our recall. The beacon is a robot rocket, fired ahead of the retrieval boat, just a spike that buries itself in the ground and starts broadcasting that welcome, welcome music. The retrieval boat homes in on it automatically three minutes later and you had better be on hand, because the bus can't wait and there won't be another one along.
+</p>
+
+<p>
+But you don't walk away on another cap trooper, not while there's a chance he's still alive — not in Rasczak's Roughnecks. Not in any outfit of the Mobile Infantry. You try to make pickup. I heard Jelly order: "Heads up, lads! Close to retrieval circle and interdict! On the bounce!"
+</p>
+
+<p>
+And I heard the beacon's sweet voice: " — to the everlasting glory of the infantry, shines the name, shines the name of Rodger Young!" and I wanted to head for it so bad I could taste it.
+</p>
+
+<p>
+Instead I was headed the other way, closing on Ace's beacon and expending what I had left of bombs and fire pills and anything else that would weigh me down. "Ace! You got his beacon?"
+</p>
+
+<p>
+"Yes. Go back, Useless!"
+</p>
+
+<p>
+"I've got you by eye now. Where is he?"
+</p>
+
+<p>
+"Right ahead of me, maybe quarter mile. Scram! He's my man ."
+</p>
+
+<p>
+I didn't answer; I simply cut left oblique to reach Ace about where he said Dizzy was.
+</p>
+
+<p>
+And found Ace standing over him, a couple of skinnies flamed down and more running away. I lit beside him. "Let's get him out of his armor — the boat'll be down any second!"
+</p>
+
+<p>
+"He's too bad hurt!"
+</p>
+
+<p>
+I looked and saw that it was true — there was actually a hole in his armor and blood coming out. And I was stumped. To make a wounded pickup you get him out of his armor... then you simply pick him up in your arms — no trouble in a powered suit — and bounce away from there. A bare man weighs less than the ammo and stuff you've expended. "What'll we do?"
+</p>
+
+<p>
+"We carry him," Ace said grimly. "Grab ahold the left side of his belt." He grabbed the right side, we manhandled Flores to his feet. "Lock on! Now... by the numbers, stand by to jump — one — two!"
+</p>
+
+<p>
+We jumped. Not far, not well. One man alone couldn't have gotten him off the ground; an armored suit is too heavy. But split it between two men and it can be done.
+We jumped — and we jumped — and again, and again, with Ace calling it and both of us steadying and catching Dizzy on each grounding. His gyros seemed to be out.
+</p>
+
+<p>
+We heard the beacon cut off as the retrieval boat landed on it — I saw it land . . . and it was too far away. We heard the acting platoon sergeant call out: "In succession, prepare to embark!"
+</p>
+
+<p>
+And Jelly called out, "Belay that order!"
+</p>
+
+<p>
+We broke at last into the open and saw the boat standing on its tail, heard the ululation of its take-off warning — saw the platoon still on the ground around it, in interdiction circle, crouching behind the shield they had formed. Heard Jelly shout, "In succession, man the boat — move!"
+</p>
+
+<p>
+And we were still too far away! I could see them peel off from the first squad, swarm into the boat as the interdiction circle tightened. And a single figure broke out of the circle, came toward us at a speed possible only to a command suit. Jelly caught us while we were in the air, grabbed Flores by his Y-rack and helped us lift. Three jumps got us to the boat. Everybody else was inside but the door was still open. We got him in and closed it while the boat pilot screamed that we had made her miss rendezvous and now we had all bought it! Jelly paid no attention to her; we laid Flores down and lay down beside him. As the blast hit us Jelly was saying to himself, "All present, Lieutenant. Three men hurt — but all present!"
+</p>
+
+<p>
+I'll say this for Captain Deladrier: they don't make any better pilots. A rendezvous, boat to ship in orbit, is precisely calculated. I don't know how, but it is, and you don't change it. You can't.
+</p>
+
+<p>
+Only she did. She saw in her scope that the boat had failed to blast on time; she braked back, picked up speed again — and matched and took us in, just by eye and touch, no time to compute it. If the Almighty ever needs an assistant to keep the stars in their courses, I know where he can look.
+</p>
+
+<p>
+Flores died on the way up.
+</p>
+
+<p>
+ -- repeat --
+</p>
+
+<p>
+Then suddenly nothing. Nothing at all. No sound, no pressure, no weight. Floating in darkness... free fall, maybe thirty miles up, above the effective atmosphere, falling weightlessly toward the surface of a planet you've never seen. But I'm not shaking now; it's the wait beforehand that wears. Once you unload, you can't get hurt — because if anything goes wrong it will happen so fast that you'll buy it without noticing that you're dead, hardly.
+</p>
+
+<p>
+Almost at once I felt the capsule twist and sway, then steady down so that my weight was on my back...weight that built up quickly until I was at my full weight (0.87 gee, we had been told) for that planet as the capsule reached terminal velocity for the thin upper atmosphere. A pilot who is a real artist (and the Captain was) will approach and brake so that your launching speed as you shoot out of the tube places you just dead in space relative to the rotational speed of the planet at that latitude. The loaded capsules are heavy; they punch through the high, thin winds of the upper atmosphere without being blown too far out of position — but just the same a platoon is bound to disperse on the way down, lose some of the perfect formation in which it unloads. A sloppy pilot can make this still worse, scatter a strike group over so much terrain that it can't make rendezvous for retrieval, much less carry out its mission. An infantryman can fight only if somebody else delivers him to his zone; in a way I suppose pilots are just as essential as we are.
+</p>
+
+<p>
+I could tell from the gentle way my capsule entered the atmosphere that the Captain had laid us down with as near zero lateral vector as you could ask for. I felt happy — not only a tight formation when we hit and no time wasted, but also a pilot who puts you down properly is a pilot who is smart and precise on retrieval.
+</p>
+
+<p>
+The outer shell burned away and sloughed off — unevenly, for I tumbled. Then the rest of it went and I straightened out. The turbulence brakes of the second shell bit in and the ride got rough... and still rougher as they burned off one at a time and the second shell began to go to pieces. One of the things that helps a capsule trooper to live long enough to draw a pension is that the skins peeling off his capsule not only slow him down, they also fill the sky over the target area with so much junk that radar picks up reflections from dozens of targets for each man in the drop, any one of which could be a man, or a bomb, or anything. It's enough to give a ballistic computer nervous breakdowns — and does. To add to the fun your ship lays a series of dummy eggs in the seconds immediately following your drop, dummies that will fall faster because they don't slough. They get under you, explode, throw out "window," even operate as transponders, rocket sideways, and do other things to add to the confusion of your reception committee on the ground.
+</p>
+
+<p>
+In the meantime your ship is locked firmly on the directional beacon of your platoon leader, ignoring the radar "noise" it has created and following you in, computing your impact for future use. When the second shell was gone, the third shell automatically opened my first ribbon chute. It didn't last long but it wasn't expected to; one good, hard jerk at several gee and it went its way and I went mine. The second chute lasted a little bit longer and the third chute lasted quite a while; it began to be rather too warm inside the capsule and I started thinking about landing.
+</p>
+
+<p>
+The third shell peeled off when its last chute was gone and now I had nothing around me but my suit armor and a plastic egg. I was still strapped inside it, unable to move; it was time to decide how and where I was going to ground. Without moving my arms (I couldn't) I thumbed the switch for a proximity reading and read it when it flashed on in the instrument reflector inside my helmet in front of my forehead. A mile and eight-tenths — A little closer than I liked, especially without company. The inner egg had reached steady speed, no more help to be gained by staying inside it, and its skin temperature indicated that it would not open automatically for a while yet — so I flipped a switch with my other thumb and got rid of it.
+</p>
+
+<p>
+The first charge cut all the straps; the second charge exploded the plastic egg away from me in eight separate pieces — and I was outdoors, sitting on air, and could see! Better still, the eight discarded pieces were metal-coated (except for the small bit I had taken proximity reading through) and would give back the same reflection as an armored man. Any radar viewer, alive or cybernetic, would now have a sad time sorting me out from the junk nearest me, not to mention the thousands of other bits and pieces for miles on each side, above, and below me. Part of a mobile infantryman's training is to let him see, from the ground and both by eye and by radar, just how confusing a drop is to the forces on the ground — because you feel awful naked up there. It is easy to panic and either open a chute too soon and become a sitting duck (do ducks really sit? — if so, why?) or fail to open it and break your ankles, likewise backbone and skull. So I stretched, getting the kinks out, and looked around... then doubled up again and straightened out in a swan dive face down and took a good look. It was night down there, as planned, but infrared snoopers let you size up terrain quite well after you are used to them. The river that cut diagonally through the city was almost below me and coming up fast, shining out clearly with a higher temperature than the land. I didn't care which side of it I landed on but I didn't want to land in it; it would slow me down.
+</p>
+
+<p>
+I noticed a dash off to the right at about my altitude; some unfriendly native down below had burned what was probably a piece of my egg. So I fired my first chute at once, intending if possible to jerk myself right off his screen as he followed the targets down in closing range. I braced for the shock, rode it, then floated down for about twenty seconds before unloading the chute — not wishing to call attention to myself in still another way by not falling at the speed of the other stuff around me. It must have worked; I wasn't burned.
+</p>
+
+<p>
+About six hundred feet up I shot the second chute... saw very quickly that I was being carried over into the river, found that I was going to pass about a hundred feet up over a flat-roofed warehouse or some such by the river... blew the chute free and came in for a good enough if rather bouncy landing on the roof by means of the suit's jump jets. I was scanning for Sergeant Jelal's beacon as I hit. And found that I was on the wrong side of the river; Jelly's star showed up on the compass ring inside my helmet far south of where it should have been — I was too far north. I trotted toward the river side of the roof as I took a range and bearing on the squad leader next to me, found that he was over a mile out of position, called, "Ace! dress your line," tossed a bomb behind me as I stepped off the building and across the river. Ace answered as I could have expected — Ace should have had my spot but he didn't want to give up his squad; nevertheless he didn't fancy taking orders from me.
+</p>
+
+<p>
+The warehouse went up behind me and the blast hit me while I was still over the river, instead of being shielded by the buildings on the far side as I should have been. It darn near tumbled my gyros and I came close to tumbling myself. I had set that bomb for fifteen seconds... or had I? I suddenly realized that I had let myself get excited, the worst thing you can do once you're on the ground. "Just like a drill," that was the way, just as Jelly had warned me. Take your time and do it right, even if it takes another half second. As I hit I took another reading on Ace and told him again to realign his squad. He didn't answer but he was already doing it. I let it ride. As long as Ace did his job, I could afford to swallow his surliness — for now. But back aboard ship (if Jelly kept me on as assistant section leader) we would eventually have to pick a quiet spot and find out who was boss. He was a career corporal and I was just a term lance acting as corporal, but he was under me and you can't afford to take any lip under those circumstances. Not permanently.
+</p>
+
+<p>
+But I didn't have time then to think about it; while I was jumping the river I had spotted a juicy target and I wanted to get it before somebody else noticed it — a lovely big group of what looked like public buildings on a hill. Temples, maybe... or a palace. They were miles outside the area we were sweeping, but one rule of a smash & run is to expend at least half your ammo outside your sweep area; that way the enemy is kept confused as to where you actually are — that and keep moving, do everything fast. You're always heavily outnumbered; surprise and speed are what saves you. I was already loading my rocket launcher while I was checking on Ace and telling him for the second time to straighten up. Jelly's voice reached me right on top of that on the all-hands circuit: "Platoon! By leapfrog! Forward!" My boss, Sergeant Johnson, echoed, "By leapfrog! Odd numbers! Advance!" That left me with nothing to worry about for twenty seconds, so I jumped up on the building nearest me, raised the launcher to my shoulder, found the target and pulled the first trigger to let the rocket have a look at its target — pulled the second trigger and kissed it on its way, jumped back to the ground. "Second section, even numbers!" I called out... waited for the count in my mind and ordered, "Advance!"
+</p>
+
+<p>
+And did so myself, hopping over the next row of buildings, and, while I was in the air, fanning the first row by the river front with a hand flamer. They seemed to be wood construction and it looked like time to start a good fire — with luck, some of those warehouses would house oil products, or even explosives. As I hit, the Y-rack on my shoulders launched two small H. E. bombs a couple of hundred yards each way to my right and left flanks but I never saw what they did as just then my first rocket hit — that unmistakable (if you've ever seen one) brilliance of an atomic explosion. It was just a peewee, of course, less than two kilotons nominal yield, with tamper and implosion squeeze to produce results from a less-than-critical mass — but then who wants to be bunk mates with a cosmic catastrophe? It was enough to clean off that hilltop and make everybody in the city take shelter against fallout. Better still, any of the local yokels who happened to be outdoors and looking that way wouldn't be seeing anything else for a couple of hours — meaning me. The dash hadn't dazzled me, nor would it dazzle any of us; our face bowls are heavily leaded, we wear snoopers over our eyes — and we're trained to duck and take it on the armor if we do happen to be looking the wrong way.
+</p>
+
+<p>
+So I merely blinked hard — opened my eyes and stared straight at a local citizen just coming out of an opening in the building ahead of me. He looked at me, I looked at him, and he started to raise something — a weapon, I suppose — as Jelly called out, "Odd numbers! Advance!"
+</p>
+
+<p>
+I didn't have time to fool with him; I was a good five hundred yards short of where I should have been by then. I still had the hand flamer in my left hand; I toasted him and jumped over the building he had been coming out of, as I started to count. A hand flamer is primarily for incendiary work but it is a good defensive anti-personnel weapon in tight quarters; you don't have to aim it much.
+</p>
+
+<p>
+Between excitement and anxiety to catch up I jumped too high and too wide. It's always a temptation to get the most out of your jump gear — but don't do it! It leaves you hanging in the air for seconds, a big fat target. The way to advance is to skim over each building as you come to it, barely clearing it, and taking full advantage of cover while you're down — and never stay in one place more than a second or two, never give them time to target in on you. Be somewhere else, anywhere. Keep moving.
+</p>
+
+<p>
+</p>
+
+<p>This one I goofed — too much for one row of buildings, too little for the row beyond it; I found myself coming down on a roof. But not a nice flat one where I might have tarried three seconds to launch another peewee A-rocket; this roof was a jungle of pipes and stanchions and assorted ironmongery — a factory maybe, or some sort of chemical works. No place to land. Worse still, half a dozen natives were up there. These geezers are humanoid, eight or nine feet tall, much skinnier than we are and with a higher body temperature; they don't wear any clothes and they stand out in a set of snoopers like a neon sign. They look still funnier in daylight with your bare eyes but I would rather fight them than the arachnids — those Bugs make me queezy.
+</p>
+
+<p>
+If these laddies were up there thirty seconds earlier when my rocket hit, then they couldn't see me, or anything. But I couldn't be certain and didn't want to tangle with them in any case; it wasn't that kind of a raid. So I jumped again while I was still in the air, scattering a handful of ten-second fire pills to keep
+them busy, grounded, jumped again at once, and called out, "Second section! Even numbers!...Advance!" and kept right on going to close the gap, while trying to spot, every time I jumped, something worth expending a rocket on. I had three more of the little A-rockets and I certainly didn't intend to take any back with me.
+</p>
+
+<p>
+But I had had pounded into me that you must get your money's worth with atomic weapons — it was only the second time that I had been allowed to carry them. Right now I was trying to spot their waterworks; a direct hit on it could make the whole city uninhabitable, force them to evacuate it without directly killing anyone — just the sort of nuisance we had been sent down to commit. It should — according to the map we had studied under hypnosis — be about three miles upstream from where I was.
+</p>
+
+<p>
+But I couldn't see it; my jumps didn't take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+Fourth and Fifth squads answered, "Wilco"; Ace said, "We're already doin' it — pick up your feet." Red's beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+<p>
+At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I'm no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn't already been told to jump, I guess I wouldn't have got out of there.
+</p>
+
+<p>
+Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+<p>
+There was something on the horizon in the direction of their spaceport — administration & control, maybe, or possibly even a starship. Almost in line and about half as far away was an enormous structure which I couldn't identify even that loosely. The range to the spaceport was extreme but I let the rocket see it, said, "Go find it, baby!" and twisted its tail — slapped the last one in, sent it toward the nearer target, and jumped. That building took a direct hit just as I left it. Either a skinny had judged (correctly) that it was worth one of their buildings to try for one of us, or one of my own mates was getting mighty careless with fireworks. Either way, I didn't want to jump from that spot, even a skimmer; I decided to go through the next couple of buildings instead of over. So I grabbed the heavy flamer off my back as I hit and dipped the snoopers down over my eyes, tackled a wall in front of me with a knife beam at full power. A section of
+wall fell away and I charged in. And backed out even faster. I didn't know what it was I had cracked open. A congregation in church — a skinny flophouse —
+maybe even their defense headquarters. All I knew was that it was a very big room filled with more skinnies than I wanted to see in my whole life.
+</p>
+
+<p>
+Probably not a church, for somebody took a shot at me as I popped back out just a slug that bounced off my armor, made my ears ring, and staggered me without hurting me. But it reminded me that I wasn't supposed to leave without giving them a souvenir of my visit. I grabbed the first thing on my belt and lobbed it in — and heard it start to squawk. As they keep telling you in Basic, doing something constructive at once is better than figuring out the best thing to do hours later. By sheer chance I had done the right thing. This was a special bomb, one each issued to us for this mission with instructions to use them if we found ways to make them effective. The squawking I heard as I threw it was the bomb shouting in skinny talk (free translation): "I'm a thirty-second bomb! I'm a thirty-second bomb! Twenty-nine!... twenty-eight!... twenty-seven! — "It was supposed to frazzle their nerves. Maybe it did; it certainly frazzled mine. Kinder to shoot a man. I didn't wait for the countdown; I jumped, while I wondered whether they would find enough doors and windows to swarm out in time.
+</p>
+
+<p>
+I got a bearing on Red's blinker at the top of the jump and one on Ace as I grounded. I was falling behind again — time to hurry. But three minutes later we had closed the gap; I had Red on my left flank a half mile away. He reported it to Jelly. We heard Jelly's relaxed growl to the entire platoon: "Circle is closed, but the beacon is not down yet. Move forward slowly and mill around, make a little more trouble — but mind the lad on each side of you; don't make trouble for him. Good job, so far — don't spoil it. Platoon! By sections...Muster!"
+</p>
+
+<p>
+It looked like a good job to me, too; much of the city was burning and, although it was almost full light now, it was hard to tell whether bare eyes were better than snoopers, the smoke was so thick. Johnson, our section leader, sounded off: "Second section, call off!" I echoed, "Squads four, five, and six — call off and report!" The assortment of safe circuits we had available in the new model comm units certainly speeded things up; Jelly could talk to anybody or to his section leaders; a section leader could call his whole section, or his non-coms; and the platoon could muster twice as fast, when seconds matter. I listened to the fourth squad call off while I inventoried my remaining firepower and lobbed one bomb toward a skinny who poked his head around a corner. He left and so did I — "Mill around," the boss man had said.
+</p>
+
+<p>
+The fourth squad bumbled the call off until the squad leader remembered to fill in with Jenkins' number; the fifth squad clicked off like an abacus and I began to feel good . . . when the call off stopped after number four in Ace's squad. I called out, "Ace, where's Dizzy?"
+</p>
+
+<p>
+"Shut up," he said. "Number six! Call off!"
+</p>
+
+<p>
+"Six!" Smith answered.
+</p>
+
+<p>
+"Seven!"
+</p>
+
+<p>
+"Sixth squad, Flores missing," Ace completed it. "Squad leader out for pickup."
+</p>
+
+<p>
+"One man absent," I reported to Johnson. "Flores, squad six."
+</p>
+
+<p>
+"Missing or dead?"
+</p>
+
+<p>
+"I don't know. Squad leader and assistant section leader dropping out for pickup."
+</p>
+
+<p>
+"Johnnie, you let Ace take it."
+</p>
+
+<p>
+But I didn't hear him, so I didn't answer. I heard him report to Jelly and I heard Jelly cuss. Now look, I wasn't bucking for a medal — it's the assistant section leader's business to make pickup; he's the chaser, the last man in, expendable. The squad leaders have other work to do. As you've no doubt gathered by now the assistant section leader isn't necessary as long as the section leader is alive. Right that moment I was feeling unusually expendable, almost expended, because I was hearing the sweetest sound in the universe, the beacon the retrieval boat would land on, sounding our recall. The beacon is a robot rocket, fired ahead of the retrieval boat, just a spike that buries itself in the ground and starts broadcasting that welcome, welcome music. The retrieval boat homes in on it automatically three minutes later and you had better be on hand, because the bus can't wait and there won't be another one along.
+</p>
+
+<p>
+But you don't walk away on another cap trooper, not while there's a chance he's still alive — not in Rasczak's Roughnecks. Not in any outfit of the Mobile Infantry. You try to make pickup. I heard Jelly order: "Heads up, lads! Close to retrieval circle and interdict! On the bounce!"
+</p>
+
+<p>
+And I heard the beacon's sweet voice: " — to the everlasting glory of the infantry, shines the name, shines the name of Rodger Young!" and I wanted to head for it so bad I could taste it.
+</p>
+
+<p>
+Instead I was headed the other way, closing on Ace's beacon and expending what I had left of bombs and fire pills and anything else that would weigh me down. "Ace! You got his beacon?"
+</p>
+
+<p>
+"Yes. Go back, Useless!"
+</p>
+
+<p>
+"I've got you by eye now. Where is he?"
+</p>
+
+<p>
+"Right ahead of me, maybe quarter mile. Scram! He's my man ."
+</p>
+
+<p>
+I didn't answer; I simply cut left oblique to reach Ace about where he said Dizzy was.
+</p>
+
+<p>
+And found Ace standing over him, a couple of skinnies flamed down and more running away. I lit beside him. "Let's get him out of his armor — the boat'll be down any second!"
+</p>
+
+<p>
+"He's too bad hurt!"
+</p>
+
+<p>
+I looked and saw that it was true — there was actually a hole in his armor and blood coming out. And I was stumped. To make a wounded pickup you get him out of his armor... then you simply pick him up in your arms — no trouble in a powered suit — and bounce away from there. A bare man weighs less than the ammo and stuff you've expended. "What'll we do?"
+</p>
+
+<p>
+"We carry him," Ace said grimly. "Grab ahold the left side of his belt." He grabbed the right side, we manhandled Flores to his feet. "Lock on! Now... by the numbers, stand by to jump — one — two!"
+</p>
+
+<p>
+We jumped. Not far, not well. One man alone couldn't have gotten him off the ground; an armored suit is too heavy. But split it between two men and it can be done.
+We jumped — and we jumped — and again, and again, with Ace calling it and both of us steadying and catching Dizzy on each grounding. His gyros seemed to be out.
+</p>
+
+<p>
+We heard the beacon cut off as the retrieval boat landed on it — I saw it land . . . and it was too far away. We heard the acting platoon sergeant call out: "In succession, prepare to embark!"
+</p>
+
+<p>
+And Jelly called out, "Belay that order!"
+</p>
+
+<p>
+We broke at last into the open and saw the boat standing on its tail, heard the ululation of its take-off warning — saw the platoon still on the ground around it, in interdiction circle, crouching behind the shield they had formed. Heard Jelly shout, "In succession, man the boat — move!"
+</p>
+
+<p>
+And we were still too far away! I could see them peel off from the first squad, swarm into the boat as the interdiction circle tightened. And a single figure broke out of the circle, came toward us at a speed possible only to a command suit. Jelly caught us while we were in the air, grabbed Flores by his Y-rack and helped us lift. Three jumps got us to the boat. Everybody else was inside but the door was still open. We got him in and closed it while the boat pilot screamed that we had made her miss rendezvous and now we had all bought it! Jelly paid no attention to her; we laid Flores down and lay down beside him. As the blast hit us Jelly was saying to himself, "All present, Lieutenant. Three men hurt — but all present!"
+</p>
+
+<p>
+I'll say this for Captain Deladrier: they don't make any better pilots. A rendezvous, boat to ship in orbit, is precisely calculated. I don't know how, but it is, and you don't change it. You can't.
+</p>
+
+<p>
+Only she did. She saw in her scope that the boat had failed to blast on time; she braked back, picked up speed again — and matched and took us in, just by eye and touch, no time to compute it. If the Almighty ever needs an assistant to keep the stars in their courses, I know where he can look.
+</p>
+
+<p>
+Flores died on the way up.
+</p>
+
+</body>
+
+</html>
\ No newline at end of file
diff --git a/src/cachingpolicy/htdocs/index_huge.html b/src/cachingpolicy/htdocs/index_huge.html
new file mode 100644
index 0000000..75ded12
--- /dev/null
+++ b/src/cachingpolicy/htdocs/index_huge.html
@@ -0,0 +1,2113 @@
+<html>
+
+<body>
+
+<p>
+	A long text page. Here is some text:
+</p>
+
+<p>
+Then suddenly nothing. Nothing at all. No sound, no pressure, no weight. Floating in darkness... free fall, maybe thirty miles up, above the effective atmosphere, falling weightlessly toward the surface of a planet you've never seen. But I'm not shaking now; it's the wait beforehand that wears. Once you unload, you can't get hurt — because if anything goes wrong it will happen so fast that you'll buy it without noticing that you're dead, hardly.
+</p>
+
+<p>
+Almost at once I felt the capsule twist and sway, then steady down so that my weight was on my back...weight that built up quickly until I was at my full weight (0.87 gee, we had been told) for that planet as the capsule reached terminal velocity for the thin upper atmosphere. A pilot who is a real artist (and the Captain was) will approach and brake so that your launching speed as you shoot out of the tube places you just dead in space relative to the rotational speed of the planet at that latitude. The loaded capsules are heavy; they punch through the high, thin winds of the upper atmosphere without being blown too far out of position — but just the same a platoon is bound to disperse on the way down, lose some of the perfect formation in which it unloads. A sloppy pilot can make this still worse, scatter a strike group over so much terrain that it can't make rendezvous for retrieval, much less carry out its mission. An infantryman can fight only if somebody else delivers him to his zone; in a way I suppose pilots are just as essential as we are.
+</p>
+
+<p>
+I could tell from the gentle way my capsule entered the atmosphere that the Captain had laid us down with as near zero lateral vector as you could ask for. I felt happy — not only a tight formation when we hit and no time wasted, but also a pilot who puts you down properly is a pilot who is smart and precise on retrieval.
+</p>
+
+<p>
+The outer shell burned away and sloughed off — unevenly, for I tumbled. Then the rest of it went and I straightened out. The turbulence brakes of the second shell bit in and the ride got rough... and still rougher as they burned off one at a time and the second shell began to go to pieces. One of the things that helps a capsule trooper to live long enough to draw a pension is that the skins peeling off his capsule not only slow him down, they also fill the sky over the target area with so much junk that radar picks up reflections from dozens of targets for each man in the drop, any one of which could be a man, or a bomb, or anything. It's enough to give a ballistic computer nervous breakdowns — and does. To add to the fun your ship lays a series of dummy eggs in the seconds immediately following your drop, dummies that will fall faster because they don't slough. They get under you, explode, throw out "window," even operate as transponders, rocket sideways, and do other things to add to the confusion of your reception committee on the ground.
+</p>
+
+<p>
+In the meantime your ship is locked firmly on the directional beacon of your platoon leader, ignoring the radar "noise" it has created and following you in, computing your impact for future use. When the second shell was gone, the third shell automatically opened my first ribbon chute. It didn't last long but it wasn't expected to; one good, hard jerk at several gee and it went its way and I went mine. The second chute lasted a little bit longer and the third chute lasted quite a while; it began to be rather too warm inside the capsule and I started thinking about landing.
+</p>
+
+<p>
+The third shell peeled off when its last chute was gone and now I had nothing around me but my suit armor and a plastic egg. I was still strapped inside it, unable to move; it was time to decide how and where I was going to ground. Without moving my arms (I couldn't) I thumbed the switch for a proximity reading and read it when it flashed on in the instrument reflector inside my helmet in front of my forehead. A mile and eight-tenths — A little closer than I liked, especially without company. The inner egg had reached steady speed, no more help to be gained by staying inside it, and its skin temperature indicated that it would not open automatically for a while yet — so I flipped a switch with my other thumb and got rid of it.
+</p>
+
+<p>
+The first charge cut all the straps; the second charge exploded the plastic egg away from me in eight separate pieces — and I was outdoors, sitting on air, and could see! Better still, the eight discarded pieces were metal-coated (except for the small bit I had taken proximity reading through) and would give back the same reflection as an armored man. Any radar viewer, alive or cybernetic, would now have a sad time sorting me out from the junk nearest me, not to mention the thousands of other bits and pieces for miles on each side, above, and below me. Part of a mobile infantryman's training is to let him see, from the ground and both by eye and by radar, just how confusing a drop is to the forces on the ground — because you feel awful naked up there. It is easy to panic and either open a chute too soon and become a sitting duck (do ducks really sit? — if so, why?) or fail to open it and break your ankles, likewise backbone and skull. So I stretched, getting the kinks out, and looked around... then doubled up again and straightened out in a swan dive face down and took a good look. It was night down there, as planned, but infrared snoopers let you size up terrain quite well after you are used to them. The river that cut diagonally through the city was almost below me and coming up fast, shining out clearly with a higher temperature than the land. I didn't care which side of it I landed on but I didn't want to land in it; it would slow me down.
+</p>
+
+<p>
+I noticed a dash off to the right at about my altitude; some unfriendly native down below had burned what was probably a piece of my egg. So I fired my first chute at once, intending if possible to jerk myself right off his screen as he followed the targets down in closing range. I braced for the shock, rode it, then floated down for about twenty seconds before unloading the chute — not wishing to call attention to myself in still another way by not falling at the speed of the other stuff around me. It must have worked; I wasn't burned.
+</p>
+
+<p>
+About six hundred feet up I shot the second chute... saw very quickly that I was being carried over into the river, found that I was going to pass about a hundred feet up over a flat-roofed warehouse or some such by the river... blew the chute free and came in for a good enough if rather bouncy landing on the roof by means of the suit's jump jets. I was scanning for Sergeant Jelal's beacon as I hit. And found that I was on the wrong side of the river; Jelly's star showed up on the compass ring inside my helmet far south of where it should have been — I was too far north. I trotted toward the river side of the roof as I took a range and bearing on the squad leader next to me, found that he was over a mile out of position, called, "Ace! dress your line," tossed a bomb behind me as I stepped off the building and across the river. Ace answered as I could have expected — Ace should have had my spot but he didn't want to give up his squad; nevertheless he didn't fancy taking orders from me.
+</p>
+
+<p>
+The warehouse went up behind me and the blast hit me while I was still over the river, instead of being shielded by the buildings on the far side as I should have been. It darn near tumbled my gyros and I came close to tumbling myself. I had set that bomb for fifteen seconds... or had I? I suddenly realized that I had let myself get excited, the worst thing you can do once you're on the ground. "Just like a drill," that was the way, just as Jelly had warned me. Take your time and do it right, even if it takes another half second. As I hit I took another reading on Ace and told him again to realign his squad. He didn't answer but he was already doing it. I let it ride. As long as Ace did his job, I could afford to swallow his surliness — for now. But back aboard ship (if Jelly kept me on as assistant section leader) we would eventually have to pick a quiet spot and find out who was boss. He was a career corporal and I was just a term lance acting as corporal, but he was under me and you can't afford to take any lip under those circumstances. Not permanently.
+</p>
+
+<p>
+But I didn't have time then to think about it; while I was jumping the river I had spotted a juicy target and I wanted to get it before somebody else noticed it — a lovely big group of what looked like public buildings on a hill. Temples, maybe... or a palace. They were miles outside the area we were sweeping, but one rule of a smash & run is to expend at least half your ammo outside your sweep area; that way the enemy is kept confused as to where you actually are — that and keep moving, do everything fast. You're always heavily outnumbered; surprise and speed are what saves you. I was already loading my rocket launcher while I was checking on Ace and telling him for the second time to straighten up. Jelly's voice reached me right on top of that on the all-hands circuit: "Platoon! By leapfrog! Forward!" My boss, Sergeant Johnson, echoed, "By leapfrog! Odd numbers! Advance!" That left me with nothing to worry about for twenty seconds, so I jumped up on the building nearest me, raised the launcher to my shoulder, found the target and pulled the first trigger to let the rocket have a look at its target — pulled the second trigger and kissed it on its way, jumped back to the ground. "Second section, even numbers!" I called out... waited for the count in my mind and ordered, "Advance!"
+</p>
+
+<p>
+And did so myself, hopping over the next row of buildings, and, while I was in the air, fanning the first row by the river front with a hand flamer. They seemed to be wood construction and it looked like time to start a good fire — with luck, some of those warehouses would house oil products, or even explosives. As I hit, the Y-rack on my shoulders launched two small H. E. bombs a couple of hundred yards each way to my right and left flanks but I never saw what they did as just then my first rocket hit — that unmistakable (if you've ever seen one) brilliance of an atomic explosion. It was just a peewee, of course, less than two kilotons nominal yield, with tamper and implosion squeeze to produce results from a less-than-critical mass — but then who wants to be bunk mates with a cosmic catastrophe? It was enough to clean off that hilltop and make everybody in the city take shelter against fallout. Better still, any of the local yokels who happened to be outdoors and looking that way wouldn't be seeing anything else for a couple of hours — meaning me. The dash hadn't dazzled me, nor would it dazzle any of us; our face bowls are heavily leaded, we wear snoopers over our eyes — and we're trained to duck and take it on the armor if we do happen to be looking the wrong way.
+</p>
+
+<p>
+So I merely blinked hard — opened my eyes and stared straight at a local citizen just coming out of an opening in the building ahead of me. He looked at me, I looked at him, and he started to raise something — a weapon, I suppose — as Jelly called out, "Odd numbers! Advance!"
+</p>
+
+<p>
+I didn't have time to fool with him; I was a good five hundred yards short of where I should have been by then. I still had the hand flamer in my left hand; I toasted him and jumped over the building he had been coming out of, as I started to count. A hand flamer is primarily for incendiary work but it is a good defensive anti-personnel weapon in tight quarters; you don't have to aim it much.
+</p>
+
+<p>
+Between excitement and anxiety to catch up I jumped too high and too wide. It's always a temptation to get the most out of your jump gear — but don't do it! It leaves you hanging in the air for seconds, a big fat target. The way to advance is to skim over each building as you come to it, barely clearing it, and taking full advantage of cover while you're down — and never stay in one place more than a second or two, never give them time to target in on you. Be somewhere else, anywhere. Keep moving.
+</p>
+
+<p>
+</p>
+
+<p>This one I goofed — too much for one row of buildings, too little for the row beyond it; I found myself coming down on a roof. But not a nice flat one where I might have tarried three seconds to launch another peewee A-rocket; this roof was a jungle of pipes and stanchions and assorted ironmongery — a factory maybe, or some sort of chemical works. No place to land. Worse still, half a dozen natives were up there. These geezers are humanoid, eight or nine feet tall, much skinnier than we are and with a higher body temperature; they don't wear any clothes and they stand out in a set of snoopers like a neon sign. They look still funnier in daylight with your bare eyes but I would rather fight them than the arachnids — those Bugs make me queezy.
+</p>
+
+<p>
+If these laddies were up there thirty seconds earlier when my rocket hit, then they couldn't see me, or anything. But I couldn't be certain and didn't want to tangle with them in any case; it wasn't that kind of a raid. So I jumped again while I was still in the air, scattering a handful of ten-second fire pills to keep
+them busy, grounded, jumped again at once, and called out, "Second section! Even numbers!...Advance!" and kept right on going to close the gap, while trying to spot, every time I jumped, something worth expending a rocket on. I had three more of the little A-rockets and I certainly didn't intend to take any back with me.
+</p>
+
+<p>
+But I had had pounded into me that you must get your money's worth with atomic weapons — it was only the second time that I had been allowed to carry them. Right now I was trying to spot their waterworks; a direct hit on it could make the whole city uninhabitable, force them to evacuate it without directly killing anyone — just the sort of nuisance we had been sent down to commit. It should — according to the map we had studied under hypnosis — be about three miles upstream from where I was.
+</p>
+
+<p>
+But I couldn't see it; my jumps didn't take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+Fourth and Fifth squads answered, "Wilco"; Ace said, "We're already doin' it — pick up your feet." Red's beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+<p>
+At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I'm no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn't already been told to jump, I guess I wouldn't have got out of there.
+</p>
+
+<p>
+Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+<p>
+There was something on the horizon in the direction of their spaceport — administration & control, maybe, or possibly even a starship. Almost in line and about half as far away was an enormous structure which I couldn't identify even that loosely. The range to the spaceport was extreme but I let the rocket see it, said, "Go find it, baby!" and twisted its tail — slapped the last one in, sent it toward the nearer target, and jumped. That building took a direct hit just as I left it. Either a skinny had judged (correctly) that it was worth one of their buildings to try for one of us, or one of my own mates was getting mighty careless with fireworks. Either way, I didn't want to jump from that spot, even a skimmer; I decided to go through the next couple of buildings instead of over. So I grabbed the heavy flamer off my back as I hit and dipped the snoopers down over my eyes, tackled a wall in front of me with a knife beam at full power. A section of
+wall fell away and I charged in. And backed out even faster. I didn't know what it was I had cracked open. A congregation in church — a skinny flophouse —
+maybe even their defense headquarters. All I knew was that it was a very big room filled with more skinnies than I wanted to see in my whole life.
+</p>
+
+<p>
+Probably not a church, for somebody took a shot at me as I popped back out just a slug that bounced off my armor, made my ears ring, and staggered me without hurting me. But it reminded me that I wasn't supposed to leave without giving them a souvenir of my visit. I grabbed the first thing on my belt and lobbed it in — and heard it start to squawk. As they keep telling you in Basic, doing something constructive at once is better than figuring out the best thing to do hours later. By sheer chance I had done the right thing. This was a special bomb, one each issued to us for this mission with instructions to use them if we found ways to make them effective. The squawking I heard as I threw it was the bomb shouting in skinny talk (free translation): "I'm a thirty-second bomb! I'm a thirty-second bomb! Twenty-nine!... twenty-eight!... twenty-seven! — "It was supposed to frazzle their nerves. Maybe it did; it certainly frazzled mine. Kinder to shoot a man. I didn't wait for the countdown; I jumped, while I wondered whether they would find enough doors and windows to swarm out in time.
+</p>
+
+<p>
+I got a bearing on Red's blinker at the top of the jump and one on Ace as I grounded. I was falling behind again — time to hurry. But three minutes later we had closed the gap; I had Red on my left flank a half mile away. He reported it to Jelly. We heard Jelly's relaxed growl to the entire platoon: "Circle is closed, but the beacon is not down yet. Move forward slowly and mill around, make a little more trouble — but mind the lad on each side of you; don't make trouble for him. Good job, so far — don't spoil it. Platoon! By sections...Muster!"
+</p>
+
+<p>
+It looked like a good job to me, too; much of the city was burning and, although it was almost full light now, it was hard to tell whether bare eyes were better than snoopers, the smoke was so thick. Johnson, our section leader, sounded off: "Second section, call off!" I echoed, "Squads four, five, and six — call off and report!" The assortment of safe circuits we had available in the new model comm units certainly speeded things up; Jelly could talk to anybody or to his section leaders; a section leader could call his whole section, or his non-coms; and the platoon could muster twice as fast, when seconds matter. I listened to the fourth squad call off while I inventoried my remaining firepower and lobbed one bomb toward a skinny who poked his head around a corner. He left and so did I — "Mill around," the boss man had said.
+</p>
+
+<p>
+The fourth squad bumbled the call off until the squad leader remembered to fill in with Jenkins' number; the fifth squad clicked off like an abacus and I began to feel good . . . when the call off stopped after number four in Ace's squad. I called out, "Ace, where's Dizzy?"
+</p>
+
+<p>
+"Shut up," he said. "Number six! Call off!"
+</p>
+
+<p>
+"Six!" Smith answered.
+</p>
+
+<p>
+"Seven!"
+</p>
+
+<p>
+"Sixth squad, Flores missing," Ace completed it. "Squad leader out for pickup."
+</p>
+
+<p>
+"One man absent," I reported to Johnson. "Flores, squad six."
+</p>
+
+<p>
+"Missing or dead?"
+</p>
+
+<p>
+"I don't know. Squad leader and assistant section leader dropping out for pickup."
+</p>
+
+<p>
+"Johnnie, you let Ace take it."
+</p>
+
+<p>
+But I didn't hear him, so I didn't answer. I heard him report to Jelly and I heard Jelly cuss. Now look, I wasn't bucking for a medal — it's the assistant section leader's business to make pickup; he's the chaser, the last man in, expendable. The squad leaders have other work to do. As you've no doubt gathered by now the assistant section leader isn't necessary as long as the section leader is alive. Right that moment I was feeling unusually expendable, almost expended, because I was hearing the sweetest sound in the universe, the beacon the retrieval boat would land on, sounding our recall. The beacon is a robot rocket, fired ahead of the retrieval boat, just a spike that buries itself in the ground and starts broadcasting that welcome, welcome music. The retrieval boat homes in on it automatically three minutes later and you had better be on hand, because the bus can't wait and there won't be another one along.
+</p>
+
+<p>
+But you don't walk away on another cap trooper, not while there's a chance he's still alive — not in Rasczak's Roughnecks. Not in any outfit of the Mobile Infantry. You try to make pickup. I heard Jelly order: "Heads up, lads! Close to retrieval circle and interdict! On the bounce!"
+</p>
+
+<p>
+And I heard the beacon's sweet voice: " — to the everlasting glory of the infantry, shines the name, shines the name of Rodger Young!" and I wanted to head for it so bad I could taste it.
+</p>
+
+<p>
+Instead I was headed the other way, closing on Ace's beacon and expending what I had left of bombs and fire pills and anything else that would weigh me down. "Ace! You got his beacon?"
+</p>
+
+<p>
+"Yes. Go back, Useless!"
+</p>
+
+<p>
+"I've got you by eye now. Where is he?"
+</p>
+
+<p>
+"Right ahead of me, maybe quarter mile. Scram! He's my man ."
+</p>
+
+<p>
+I didn't answer; I simply cut left oblique to reach Ace about where he said Dizzy was.
+</p>
+
+<p>
+And found Ace standing over him, a couple of skinnies flamed down and more running away. I lit beside him. "Let's get him out of his armor — the boat'll be down any second!"
+</p>
+
+<p>
+"He's too bad hurt!"
+</p>
+
+<p>
+I looked and saw that it was true — there was actually a hole in his armor and blood coming out. And I was stumped. To make a wounded pickup you get him out of his armor... then you simply pick him up in your arms — no trouble in a powered suit — and bounce away from there. A bare man weighs less than the ammo and stuff you've expended. "What'll we do?"
+</p>
+
+<p>
+"We carry him," Ace said grimly. "Grab ahold the left side of his belt." He grabbed the right side, we manhandled Flores to his feet. "Lock on! Now... by the numbers, stand by to jump — one — two!"
+</p>
+
+<p>
+We jumped. Not far, not well. One man alone couldn't have gotten him off the ground; an armored suit is too heavy. But split it between two men and it can be done.
+We jumped — and we jumped — and again, and again, with Ace calling it and both of us steadying and catching Dizzy on each grounding. His gyros seemed to be out.
+</p>
+
+<p>
+We heard the beacon cut off as the retrieval boat landed on it — I saw it land . . . and it was too far away. We heard the acting platoon sergeant call out: "In succession, prepare to embark!"
+</p>
+
+<p>
+And Jelly called out, "Belay that order!"
+</p>
+
+<p>
+We broke at last into the open and saw the boat standing on its tail, heard the ululation of its take-off warning — saw the platoon still on the ground around it, in interdiction circle, crouching behind the shield they had formed. Heard Jelly shout, "In succession, man the boat — move!"
+</p>
+
+<p>
+And we were still too far away! I could see them peel off from the first squad, swarm into the boat as the interdiction circle tightened. And a single figure broke out of the circle, came toward us at a speed possible only to a command suit. Jelly caught us while we were in the air, grabbed Flores by his Y-rack and helped us lift. Three jumps got us to the boat. Everybody else was inside but the door was still open. We got him in and closed it while the boat pilot screamed that we had made her miss rendezvous and now we had all bought it! Jelly paid no attention to her; we laid Flores down and lay down beside him. As the blast hit us Jelly was saying to himself, "All present, Lieutenant. Three men hurt — but all present!"
+</p>
+
+<p>
+I'll say this for Captain Deladrier: they don't make any better pilots. A rendezvous, boat to ship in orbit, is precisely calculated. I don't know how, but it is, and you don't change it. You can't.
+</p>
+
+<p>
+Only she did. She saw in her scope that the boat had failed to blast on time; she braked back, picked up speed again — and matched and took us in, just by eye and touch, no time to compute it. If the Almighty ever needs an assistant to keep the stars in their courses, I know where he can look.
+</p>
+
+<p>
+Flores died on the way up.
+</p>
+
+<p>
+ -- repeat --
+</p>
+
+<p>
+Then suddenly nothing. Nothing at all. No sound, no pressure, no weight. Floating in darkness... free fall, maybe thirty miles up, above the effective atmosphere, falling weightlessly toward the surface of a planet you've never seen. But I'm not shaking now; it's the wait beforehand that wears. Once you unload, you can't get hurt — because if anything goes wrong it will happen so fast that you'll buy it without noticing that you're dead, hardly.
+</p>
+
+<p>
+Almost at once I felt the capsule twist and sway, then steady down so that my weight was on my back...weight that built up quickly until I was at my full weight (0.87 gee, we had been told) for that planet as the capsule reached terminal velocity for the thin upper atmosphere. A pilot who is a real artist (and the Captain was) will approach and brake so that your launching speed as you shoot out of the tube places you just dead in space relative to the rotational speed of the planet at that latitude. The loaded capsules are heavy; they punch through the high, thin winds of the upper atmosphere without being blown too far out of position — but just the same a platoon is bound to disperse on the way down, lose some of the perfect formation in which it unloads. A sloppy pilot can make this still worse, scatter a strike group over so much terrain that it can't make rendezvous for retrieval, much less carry out its mission. An infantryman can fight only if somebody else delivers him to his zone; in a way I suppose pilots are just as essential as we are.
+</p>
+
+<p>
+I could tell from the gentle way my capsule entered the atmosphere that the Captain had laid us down with as near zero lateral vector as you could ask for. I felt happy — not only a tight formation when we hit and no time wasted, but also a pilot who puts you down properly is a pilot who is smart and precise on retrieval.
+</p>
+
+<p>
+The outer shell burned away and sloughed off — unevenly, for I tumbled. Then the rest of it went and I straightened out. The turbulence brakes of the second shell bit in and the ride got rough... and still rougher as they burned off one at a time and the second shell began to go to pieces. One of the things that helps a capsule trooper to live long enough to draw a pension is that the skins peeling off his capsule not only slow him down, they also fill the sky over the target area with so much junk that radar picks up reflections from dozens of targets for each man in the drop, any one of which could be a man, or a bomb, or anything. It's enough to give a ballistic computer nervous breakdowns — and does. To add to the fun your ship lays a series of dummy eggs in the seconds immediately following your drop, dummies that will fall faster because they don't slough. They get under you, explode, throw out "window," even operate as transponders, rocket sideways, and do other things to add to the confusion of your reception committee on the ground.
+</p>
+
+<p>
+In the meantime your ship is locked firmly on the directional beacon of your platoon leader, ignoring the radar "noise" it has created and following you in, computing your impact for future use. When the second shell was gone, the third shell automatically opened my first ribbon chute. It didn't last long but it wasn't expected to; one good, hard jerk at several gee and it went its way and I went mine. The second chute lasted a little bit longer and the third chute lasted quite a while; it began to be rather too warm inside the capsule and I started thinking about landing.
+</p>
+
+<p>
+The third shell peeled off when its last chute was gone and now I had nothing around me but my suit armor and a plastic egg. I was still strapped inside it, unable to move; it was time to decide how and where I was going to ground. Without moving my arms (I couldn't) I thumbed the switch for a proximity reading and read it when it flashed on in the instrument reflector inside my helmet in front of my forehead. A mile and eight-tenths — A little closer than I liked, especially without company. The inner egg had reached steady speed, no more help to be gained by staying inside it, and its skin temperature indicated that it would not open automatically for a while yet — so I flipped a switch with my other thumb and got rid of it.
+</p>
+
+<p>
+The first charge cut all the straps; the second charge exploded the plastic egg away from me in eight separate pieces — and I was outdoors, sitting on air, and could see! Better still, the eight discarded pieces were metal-coated (except for the small bit I had taken proximity reading through) and would give back the same reflection as an armored man. Any radar viewer, alive or cybernetic, would now have a sad time sorting me out from the junk nearest me, not to mention the thousands of other bits and pieces for miles on each side, above, and below me. Part of a mobile infantryman's training is to let him see, from the ground and both by eye and by radar, just how confusing a drop is to the forces on the ground — because you feel awful naked up there. It is easy to panic and either open a chute too soon and become a sitting duck (do ducks really sit? — if so, why?) or fail to open it and break your ankles, likewise backbone and skull. So I stretched, getting the kinks out, and looked around... then doubled up again and straightened out in a swan dive face down and took a good look. It was night down there, as planned, but infrared snoopers let you size up terrain quite well after you are used to them. The river that cut diagonally through the city was almost below me and coming up fast, shining out clearly with a higher temperature than the land. I didn't care which side of it I landed on but I didn't want to land in it; it would slow me down.
+</p>
+
+<p>
+I noticed a dash off to the right at about my altitude; some unfriendly native down below had burned what was probably a piece of my egg. So I fired my first chute at once, intending if possible to jerk myself right off his screen as he followed the targets down in closing range. I braced for the shock, rode it, then floated down for about twenty seconds before unloading the chute — not wishing to call attention to myself in still another way by not falling at the speed of the other stuff around me. It must have worked; I wasn't burned.
+</p>
+
+<p>
+About six hundred feet up I shot the second chute... saw very quickly that I was being carried over into the river, found that I was going to pass about a hundred feet up over a flat-roofed warehouse or some such by the river... blew the chute free and came in for a good enough if rather bouncy landing on the roof by means of the suit's jump jets. I was scanning for Sergeant Jelal's beacon as I hit. And found that I was on the wrong side of the river; Jelly's star showed up on the compass ring inside my helmet far south of where it should have been — I was too far north. I trotted toward the river side of the roof as I took a range and bearing on the squad leader next to me, found that he was over a mile out of position, called, "Ace! dress your line," tossed a bomb behind me as I stepped off the building and across the river. Ace answered as I could have expected — Ace should have had my spot but he didn't want to give up his squad; nevertheless he didn't fancy taking orders from me.
+</p>
+
+<p>
+The warehouse went up behind me and the blast hit me while I was still over the river, instead of being shielded by the buildings on the far side as I should have been. It darn near tumbled my gyros and I came close to tumbling myself. I had set that bomb for fifteen seconds... or had I? I suddenly realized that I had let myself get excited, the worst thing you can do once you're on the ground. "Just like a drill," that was the way, just as Jelly had warned me. Take your time and do it right, even if it takes another half second. As I hit I took another reading on Ace and told him again to realign his squad. He didn't answer but he was already doing it. I let it ride. As long as Ace did his job, I could afford to swallow his surliness — for now. But back aboard ship (if Jelly kept me on as assistant section leader) we would eventually have to pick a quiet spot and find out who was boss. He was a career corporal and I was just a term lance acting as corporal, but he was under me and you can't afford to take any lip under those circumstances. Not permanently.
+</p>
+
+<p>
+But I didn't have time then to think about it; while I was jumping the river I had spotted a juicy target and I wanted to get it before somebody else noticed it — a lovely big group of what looked like public buildings on a hill. Temples, maybe... or a palace. They were miles outside the area we were sweeping, but one rule of a smash & run is to expend at least half your ammo outside your sweep area; that way the enemy is kept confused as to where you actually are — that and keep moving, do everything fast. You're always heavily outnumbered; surprise and speed are what saves you. I was already loading my rocket launcher while I was checking on Ace and telling him for the second time to straighten up. Jelly's voice reached me right on top of that on the all-hands circuit: "Platoon! By leapfrog! Forward!" My boss, Sergeant Johnson, echoed, "By leapfrog! Odd numbers! Advance!" That left me with nothing to worry about for twenty seconds, so I jumped up on the building nearest me, raised the launcher to my shoulder, found the target and pulled the first trigger to let the rocket have a look at its target — pulled the second trigger and kissed it on its way, jumped back to the ground. "Second section, even numbers!" I called out... waited for the count in my mind and ordered, "Advance!"
+</p>
+
+<p>
+And did so myself, hopping over the next row of buildings, and, while I was in the air, fanning the first row by the river front with a hand flamer. They seemed to be wood construction and it looked like time to start a good fire — with luck, some of those warehouses would house oil products, or even explosives. As I hit, the Y-rack on my shoulders launched two small H. E. bombs a couple of hundred yards each way to my right and left flanks but I never saw what they did as just then my first rocket hit — that unmistakable (if you've ever seen one) brilliance of an atomic explosion. It was just a peewee, of course, less than two kilotons nominal yield, with tamper and implosion squeeze to produce results from a less-than-critical mass — but then who wants to be bunk mates with a cosmic catastrophe? It was enough to clean off that hilltop and make everybody in the city take shelter against fallout. Better still, any of the local yokels who happened to be outdoors and looking that way wouldn't be seeing anything else for a couple of hours — meaning me. The dash hadn't dazzled me, nor would it dazzle any of us; our face bowls are heavily leaded, we wear snoopers over our eyes — and we're trained to duck and take it on the armor if we do happen to be looking the wrong way.
+</p>
+
+<p>
+So I merely blinked hard — opened my eyes and stared straight at a local citizen just coming out of an opening in the building ahead of me. He looked at me, I looked at him, and he started to raise something — a weapon, I suppose — as Jelly called out, "Odd numbers! Advance!"
+</p>
+
+<p>
+I didn't have time to fool with him; I was a good five hundred yards short of where I should have been by then. I still had the hand flamer in my left hand; I toasted him and jumped over the building he had been coming out of, as I started to count. A hand flamer is primarily for incendiary work but it is a good defensive anti-personnel weapon in tight quarters; you don't have to aim it much.
+</p>
+
+<p>
+Between excitement and anxiety to catch up I jumped too high and too wide. It's always a temptation to get the most out of your jump gear — but don't do it! It leaves you hanging in the air for seconds, a big fat target. The way to advance is to skim over each building as you come to it, barely clearing it, and taking full advantage of cover while you're down — and never stay in one place more than a second or two, never give them time to target in on you. Be somewhere else, anywhere. Keep moving.
+</p>
+
+<p>
+</p>
+
+<p>This one I goofed — too much for one row of buildings, too little for the row beyond it; I found myself coming down on a roof. But not a nice flat one where I might have tarried three seconds to launch another peewee A-rocket; this roof was a jungle of pipes and stanchions and assorted ironmongery — a factory maybe, or some sort of chemical works. No place to land. Worse still, half a dozen natives were up there. These geezers are humanoid, eight or nine feet tall, much skinnier than we are and with a higher body temperature; they don't wear any clothes and they stand out in a set of snoopers like a neon sign. They look still funnier in daylight with your bare eyes but I would rather fight them than the arachnids — those Bugs make me queezy.
+</p>
+
+<p>
+If these laddies were up there thirty seconds earlier when my rocket hit, then they couldn't see me, or anything. But I couldn't be certain and didn't want to tangle with them in any case; it wasn't that kind of a raid. So I jumped again while I was still in the air, scattering a handful of ten-second fire pills to keep
+them busy, grounded, jumped again at once, and called out, "Second section! Even numbers!...Advance!" and kept right on going to close the gap, while trying to spot, every time I jumped, something worth expending a rocket on. I had three more of the little A-rockets and I certainly didn't intend to take any back with me.
+</p>
+
+<p>
+But I had had pounded into me that you must get your money's worth with atomic weapons — it was only the second time that I had been allowed to carry them. Right now I was trying to spot their waterworks; a direct hit on it could make the whole city uninhabitable, force them to evacuate it without directly killing anyone — just the sort of nuisance we had been sent down to commit. It should — according to the map we had studied under hypnosis — be about three miles upstream from where I was.
+</p>
+
+<p>
+But I couldn't see it; my jumps didn't take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+Fourth and Fifth squads answered, "Wilco"; Ace said, "We're already doin' it — pick up your feet." Red's beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+<p>
+At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I'm no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn't already been told to jump, I guess I wouldn't have got out of there.
+</p>
+
+<p>
+Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+<p>
+There was something on the horizon in the direction of their spaceport — administration & control, maybe, or possibly even a starship. Almost in line and about half as far away was an enormous structure which I couldn't identify even that loosely. The range to the spaceport was extreme but I let the rocket see it, said, "Go find it, baby!" and twisted its tail — slapped the last one in, sent it toward the nearer target, and jumped. That building took a direct hit just as I left it. Either a skinny had judged (correctly) that it was worth one of their buildings to try for one of us, or one of my own mates was getting mighty careless with fireworks. Either way, I didn't want to jump from that spot, even a skimmer; I decided to go through the next couple of buildings instead of over. So I grabbed the heavy flamer off my back as I hit and dipped the snoopers down over my eyes, tackled a wall in front of me with a knife beam at full power. A section of
+wall fell away and I charged in. And backed out even faster. I didn't know what it was I had cracked open. A congregation in church — a skinny flophouse —
+maybe even their defense headquarters. All I knew was that it was a very big room filled with more skinnies than I wanted to see in my whole life.
+</p>
+
+<p>
+Probably not a church, for somebody took a shot at me as I popped back out just a slug that bounced off my armor, made my ears ring, and staggered me without hurting me. But it reminded me that I wasn't supposed to leave without giving them a souvenir of my visit. I grabbed the first thing on my belt and lobbed it in — and heard it start to squawk. As they keep telling you in Basic, doing something constructive at once is better than figuring out the best thing to do hours later. By sheer chance I had done the right thing. This was a special bomb, one each issued to us for this mission with instructions to use them if we found ways to make them effective. The squawking I heard as I threw it was the bomb shouting in skinny talk (free translation): "I'm a thirty-second bomb! I'm a thirty-second bomb! Twenty-nine!... twenty-eight!... twenty-seven! — "It was supposed to frazzle their nerves. Maybe it did; it certainly frazzled mine. Kinder to shoot a man. I didn't wait for the countdown; I jumped, while I wondered whether they would find enough doors and windows to swarm out in time.
+</p>
+
+<p>
+I got a bearing on Red's blinker at the top of the jump and one on Ace as I grounded. I was falling behind again — time to hurry. But three minutes later we had closed the gap; I had Red on my left flank a half mile away. He reported it to Jelly. We heard Jelly's relaxed growl to the entire platoon: "Circle is closed, but the beacon is not down yet. Move forward slowly and mill around, make a little more trouble — but mind the lad on each side of you; don't make trouble for him. Good job, so far — don't spoil it. Platoon! By sections...Muster!"
+</p>
+
+<p>
+It looked like a good job to me, too; much of the city was burning and, although it was almost full light now, it was hard to tell whether bare eyes were better than snoopers, the smoke was so thick. Johnson, our section leader, sounded off: "Second section, call off!" I echoed, "Squads four, five, and six — call off and report!" The assortment of safe circuits we had available in the new model comm units certainly speeded things up; Jelly could talk to anybody or to his section leaders; a section leader could call his whole section, or his non-coms; and the platoon could muster twice as fast, when seconds matter. I listened to the fourth squad call off while I inventoried my remaining firepower and lobbed one bomb toward a skinny who poked his head around a corner. He left and so did I — "Mill around," the boss man had said.
+</p>
+
+<p>
+The fourth squad bumbled the call off until the squad leader remembered to fill in with Jenkins' number; the fifth squad clicked off like an abacus and I began to feel good . . . when the call off stopped after number four in Ace's squad. I called out, "Ace, where's Dizzy?"
+</p>
+
+<p>
+"Shut up," he said. "Number six! Call off!"
+</p>
+
+<p>
+"Six!" Smith answered.
+</p>
+
+<p>
+"Seven!"
+</p>
+
+<p>
+"Sixth squad, Flores missing," Ace completed it. "Squad leader out for pickup."
+</p>
+
+<p>
+"One man absent," I reported to Johnson. "Flores, squad six."
+</p>
+
+<p>
+"Missing or dead?"
+</p>
+
+<p>
+"I don't know. Squad leader and assistant section leader dropping out for pickup."
+</p>
+
+<p>
+"Johnnie, you let Ace take it."
+</p>
+
+<p>
+But I didn't hear him, so I didn't answer. I heard him report to Jelly and I heard Jelly cuss. Now look, I wasn't bucking for a medal — it's the assistant section leader's business to make pickup; he's the chaser, the last man in, expendable. The squad leaders have other work to do. As you've no doubt gathered by now the assistant section leader isn't necessary as long as the section leader is alive. Right that moment I was feeling unusually expendable, almost expended, because I was hearing the sweetest sound in the universe, the beacon the retrieval boat would land on, sounding our recall. The beacon is a robot rocket, fired ahead of the retrieval boat, just a spike that buries itself in the ground and starts broadcasting that welcome, welcome music. The retrieval boat homes in on it automatically three minutes later and you had better be on hand, because the bus can't wait and there won't be another one along.
+</p>
+
+<p>
+But you don't walk away on another cap trooper, not while there's a chance he's still alive — not in Rasczak's Roughnecks. Not in any outfit of the Mobile Infantry. You try to make pickup. I heard Jelly order: "Heads up, lads! Close to retrieval circle and interdict! On the bounce!"
+</p>
+
+<p>
+And I heard the beacon's sweet voice: " — to the everlasting glory of the infantry, shines the name, shines the name of Rodger Young!" and I wanted to head for it so bad I could taste it.
+</p>
+
+<p>
+Instead I was headed the other way, closing on Ace's beacon and expending what I had left of bombs and fire pills and anything else that would weigh me down. "Ace! You got his beacon?"
+</p>
+
+<p>
+"Yes. Go back, Useless!"
+</p>
+
+<p>
+"I've got you by eye now. Where is he?"
+</p>
+
+<p>
+"Right ahead of me, maybe quarter mile. Scram! He's my man ."
+</p>
+
+<p>
+I didn't answer; I simply cut left oblique to reach Ace about where he said Dizzy was.
+</p>
+
+<p>
+And found Ace standing over him, a couple of skinnies flamed down and more running away. I lit beside him. "Let's get him out of his armor — the boat'll be down any second!"
+</p>
+
+<p>
+"He's too bad hurt!"
+</p>
+
+<p>
+I looked and saw that it was true — there was actually a hole in his armor and blood coming out. And I was stumped. To make a wounded pickup you get him out of his armor... then you simply pick him up in your arms — no trouble in a powered suit — and bounce away from there. A bare man weighs less than the ammo and stuff you've expended. "What'll we do?"
+</p>
+
+<p>
+"We carry him," Ace said grimly. "Grab ahold the left side of his belt." He grabbed the right side, we manhandled Flores to his feet. "Lock on! Now... by the numbers, stand by to jump — one — two!"
+</p>
+
+<p>
+We jumped. Not far, not well. One man alone couldn't have gotten him off the ground; an armored suit is too heavy. But split it between two men and it can be done.
+We jumped — and we jumped — and again, and again, with Ace calling it and both of us steadying and catching Dizzy on each grounding. His gyros seemed to be out.
+</p>
+
+<p>
+We heard the beacon cut off as the retrieval boat landed on it — I saw it land . . . and it was too far away. We heard the acting platoon sergeant call out: "In succession, prepare to embark!"
+</p>
+
+<p>
+And Jelly called out, "Belay that order!"
+</p>
+
+<p>
+We broke at last into the open and saw the boat standing on its tail, heard the ululation of its take-off warning — saw the platoon still on the ground around it, in interdiction circle, crouching behind the shield they had formed. Heard Jelly shout, "In succession, man the boat — move!"
+</p>
+
+<p>
+And we were still too far away! I could see them peel off from the first squad, swarm into the boat as the interdiction circle tightened. And a single figure broke out of the circle, came toward us at a speed possible only to a command suit. Jelly caught us while we were in the air, grabbed Flores by his Y-rack and helped us lift. Three jumps got us to the boat. Everybody else was inside but the door was still open. We got him in and closed it while the boat pilot screamed that we had made her miss rendezvous and now we had all bought it! Jelly paid no attention to her; we laid Flores down and lay down beside him. As the blast hit us Jelly was saying to himself, "All present, Lieutenant. Three men hurt — but all present!"
+</p>
+
+<p>
+I'll say this for Captain Deladrier: they don't make any better pilots. A rendezvous, boat to ship in orbit, is precisely calculated. I don't know how, but it is, and you don't change it. You can't.
+</p>
+
+<p>
+Only she did. She saw in her scope that the boat had failed to blast on time; she braked back, picked up speed again — and matched and took us in, just by eye and touch, no time to compute it. If the Almighty ever needs an assistant to keep the stars in their courses, I know where he can look.
+</p>
+
+<p>
+Flores died on the way up.
+</p>
+
+<p>
+ -- repeat --
+</p>
+
+<p>
+Then suddenly nothing. Nothing at all. No sound, no pressure, no weight. Floating in darkness... free fall, maybe thirty miles up, above the effective atmosphere, falling weightlessly toward the surface of a planet you've never seen. But I'm not shaking now; it's the wait beforehand that wears. Once you unload, you can't get hurt — because if anything goes wrong it will happen so fast that you'll buy it without noticing that you're dead, hardly.
+</p>
+
+<p>
+Almost at once I felt the capsule twist and sway, then steady down so that my weight was on my back...weight that built up quickly until I was at my full weight (0.87 gee, we had been told) for that planet as the capsule reached terminal velocity for the thin upper atmosphere. A pilot who is a real artist (and the Captain was) will approach and brake so that your launching speed as you shoot out of the tube places you just dead in space relative to the rotational speed of the planet at that latitude. The loaded capsules are heavy; they punch through the high, thin winds of the upper atmosphere without being blown too far out of position — but just the same a platoon is bound to disperse on the way down, lose some of the perfect formation in which it unloads. A sloppy pilot can make this still worse, scatter a strike group over so much terrain that it can't make rendezvous for retrieval, much less carry out its mission. An infantryman can fight only if somebody else delivers him to his zone; in a way I suppose pilots are just as essential as we are.
+</p>
+
+<p>
+I could tell from the gentle way my capsule entered the atmosphere that the Captain had laid us down with as near zero lateral vector as you could ask for. I felt happy — not only a tight formation when we hit and no time wasted, but also a pilot who puts you down properly is a pilot who is smart and precise on retrieval.
+</p>
+
+<p>
+The outer shell burned away and sloughed off — unevenly, for I tumbled. Then the rest of it went and I straightened out. The turbulence brakes of the second shell bit in and the ride got rough... and still rougher as they burned off one at a time and the second shell began to go to pieces. One of the things that helps a capsule trooper to live long enough to draw a pension is that the skins peeling off his capsule not only slow him down, they also fill the sky over the target area with so much junk that radar picks up reflections from dozens of targets for each man in the drop, any one of which could be a man, or a bomb, or anything. It's enough to give a ballistic computer nervous breakdowns — and does. To add to the fun your ship lays a series of dummy eggs in the seconds immediately following your drop, dummies that will fall faster because they don't slough. They get under you, explode, throw out "window," even operate as transponders, rocket sideways, and do other things to add to the confusion of your reception committee on the ground.
+</p>
+
+<p>
+In the meantime your ship is locked firmly on the directional beacon of your platoon leader, ignoring the radar "noise" it has created and following you in, computing your impact for future use. When the second shell was gone, the third shell automatically opened my first ribbon chute. It didn't last long but it wasn't expected to; one good, hard jerk at several gee and it went its way and I went mine. The second chute lasted a little bit longer and the third chute lasted quite a while; it began to be rather too warm inside the capsule and I started thinking about landing.
+</p>
+
+<p>
+The third shell peeled off when its last chute was gone and now I had nothing around me but my suit armor and a plastic egg. I was still strapped inside it, unable to move; it was time to decide how and where I was going to ground. Without moving my arms (I couldn't) I thumbed the switch for a proximity reading and read it when it flashed on in the instrument reflector inside my helmet in front of my forehead. A mile and eight-tenths — A little closer than I liked, especially without company. The inner egg had reached steady speed, no more help to be gained by staying inside it, and its skin temperature indicated that it would not open automatically for a while yet — so I flipped a switch with my other thumb and got rid of it.
+</p>
+
+<p>
+The first charge cut all the straps; the second charge exploded the plastic egg away from me in eight separate pieces — and I was outdoors, sitting on air, and could see! Better still, the eight discarded pieces were metal-coated (except for the small bit I had taken proximity reading through) and would give back the same reflection as an armored man. Any radar viewer, alive or cybernetic, would now have a sad time sorting me out from the junk nearest me, not to mention the thousands of other bits and pieces for miles on each side, above, and below me. Part of a mobile infantryman's training is to let him see, from the ground and both by eye and by radar, just how confusing a drop is to the forces on the ground — because you feel awful naked up there. It is easy to panic and either open a chute too soon and become a sitting duck (do ducks really sit? — if so, why?) or fail to open it and break your ankles, likewise backbone and skull. So I stretched, getting the kinks out, and looked around... then doubled up again and straightened out in a swan dive face down and took a good look. It was night down there, as planned, but infrared snoopers let you size up terrain quite well after you are used to them. The river that cut diagonally through the city was almost below me and coming up fast, shining out clearly with a higher temperature than the land. I didn't care which side of it I landed on but I didn't want to land in it; it would slow me down.
+</p>
+
+<p>
+I noticed a dash off to the right at about my altitude; some unfriendly native down below had burned what was probably a piece of my egg. So I fired my first chute at once, intending if possible to jerk myself right off his screen as he followed the targets down in closing range. I braced for the shock, rode it, then floated down for about twenty seconds before unloading the chute — not wishing to call attention to myself in still another way by not falling at the speed of the other stuff around me. It must have worked; I wasn't burned.
+</p>
+
+<p>
+About six hundred feet up I shot the second chute... saw very quickly that I was being carried over into the river, found that I was going to pass about a hundred feet up over a flat-roofed warehouse or some such by the river... blew the chute free and came in for a good enough if rather bouncy landing on the roof by means of the suit's jump jets. I was scanning for Sergeant Jelal's beacon as I hit. And found that I was on the wrong side of the river; Jelly's star showed up on the compass ring inside my helmet far south of where it should have been — I was too far north. I trotted toward the river side of the roof as I took a range and bearing on the squad leader next to me, found that he was over a mile out of position, called, "Ace! dress your line," tossed a bomb behind me as I stepped off the building and across the river. Ace answered as I could have expected — Ace should have had my spot but he didn't want to give up his squad; nevertheless he didn't fancy taking orders from me.
+</p>
+
+<p>
+The warehouse went up behind me and the blast hit me while I was still over the river, instead of being shielded by the buildings on the far side as I should have been. It darn near tumbled my gyros and I came close to tumbling myself. I had set that bomb for fifteen seconds... or had I? I suddenly realized that I had let myself get excited, the worst thing you can do once you're on the ground. "Just like a drill," that was the way, just as Jelly had warned me. Take your time and do it right, even if it takes another half second. As I hit I took another reading on Ace and told him again to realign his squad. He didn't answer but he was already doing it. I let it ride. As long as Ace did his job, I could afford to swallow his surliness — for now. But back aboard ship (if Jelly kept me on as assistant section leader) we would eventually have to pick a quiet spot and find out who was boss. He was a career corporal and I was just a term lance acting as corporal, but he was under me and you can't afford to take any lip under those circumstances. Not permanently.
+</p>
+
+<p>
+But I didn't have time then to think about it; while I was jumping the river I had spotted a juicy target and I wanted to get it before somebody else noticed it — a lovely big group of what looked like public buildings on a hill. Temples, maybe... or a palace. They were miles outside the area we were sweeping, but one rule of a smash & run is to expend at least half your ammo outside your sweep area; that way the enemy is kept confused as to where you actually are — that and keep moving, do everything fast. You're always heavily outnumbered; surprise and speed are what saves you. I was already loading my rocket launcher while I was checking on Ace and telling him for the second time to straighten up. Jelly's voice reached me right on top of that on the all-hands circuit: "Platoon! By leapfrog! Forward!" My boss, Sergeant Johnson, echoed, "By leapfrog! Odd numbers! Advance!" That left me with nothing to worry about for twenty seconds, so I jumped up on the building nearest me, raised the launcher to my shoulder, found the target and pulled the first trigger to let the rocket have a look at its target — pulled the second trigger and kissed it on its way, jumped back to the ground. "Second section, even numbers!" I called out... waited for the count in my mind and ordered, "Advance!"
+</p>
+
+<p>
+And did so myself, hopping over the next row of buildings, and, while I was in the air, fanning the first row by the river front with a hand flamer. They seemed to be wood construction and it looked like time to start a good fire — with luck, some of those warehouses would house oil products, or even explosives. As I hit, the Y-rack on my shoulders launched two small H. E. bombs a couple of hundred yards each way to my right and left flanks but I never saw what they did as just then my first rocket hit — that unmistakable (if you've ever seen one) brilliance of an atomic explosion. It was just a peewee, of course, less than two kilotons nominal yield, with tamper and implosion squeeze to produce results from a less-than-critical mass — but then who wants to be bunk mates with a cosmic catastrophe? It was enough to clean off that hilltop and make everybody in the city take shelter against fallout. Better still, any of the local yokels who happened to be outdoors and looking that way wouldn't be seeing anything else for a couple of hours — meaning me. The dash hadn't dazzled me, nor would it dazzle any of us; our face bowls are heavily leaded, we wear snoopers over our eyes — and we're trained to duck and take it on the armor if we do happen to be looking the wrong way.
+</p>
+
+<p>
+So I merely blinked hard — opened my eyes and stared straight at a local citizen just coming out of an opening in the building ahead of me. He looked at me, I looked at him, and he started to raise something — a weapon, I suppose — as Jelly called out, "Odd numbers! Advance!"
+</p>
+
+<p>
+I didn't have time to fool with him; I was a good five hundred yards short of where I should have been by then. I still had the hand flamer in my left hand; I toasted him and jumped over the building he had been coming out of, as I started to count. A hand flamer is primarily for incendiary work but it is a good defensive anti-personnel weapon in tight quarters; you don't have to aim it much.
+</p>
+
+<p>
+Between excitement and anxiety to catch up I jumped too high and too wide. It's always a temptation to get the most out of your jump gear — but don't do it! It leaves you hanging in the air for seconds, a big fat target. The way to advance is to skim over each building as you come to it, barely clearing it, and taking full advantage of cover while you're down — and never stay in one place more than a second or two, never give them time to target in on you. Be somewhere else, anywhere. Keep moving.
+</p>
+
+<p>
+</p>
+
+<p>This one I goofed — too much for one row of buildings, too little for the row beyond it; I found myself coming down on a roof. But not a nice flat one where I might have tarried three seconds to launch another peewee A-rocket; this roof was a jungle of pipes and stanchions and assorted ironmongery — a factory maybe, or some sort of chemical works. No place to land. Worse still, half a dozen natives were up there. These geezers are humanoid, eight or nine feet tall, much skinnier than we are and with a higher body temperature; they don't wear any clothes and they stand out in a set of snoopers like a neon sign. They look still funnier in daylight with your bare eyes but I would rather fight them than the arachnids — those Bugs make me queezy.
+</p>
+
+<p>
+If these laddies were up there thirty seconds earlier when my rocket hit, then they couldn't see me, or anything. But I couldn't be certain and didn't want to tangle with them in any case; it wasn't that kind of a raid. So I jumped again while I was still in the air, scattering a handful of ten-second fire pills to keep
+them busy, grounded, jumped again at once, and called out, "Second section! Even numbers!...Advance!" and kept right on going to close the gap, while trying to spot, every time I jumped, something worth expending a rocket on. I had three more of the little A-rockets and I certainly didn't intend to take any back with me.
+</p>
+
+<p>
+But I had had pounded into me that you must get your money's worth with atomic weapons — it was only the second time that I had been allowed to carry them. Right now I was trying to spot their waterworks; a direct hit on it could make the whole city uninhabitable, force them to evacuate it without directly killing anyone — just the sort of nuisance we had been sent down to commit. It should — according to the map we had studied under hypnosis — be about three miles upstream from where I was.
+</p>
+
+<p>
+But I couldn't see it; my jumps didn't take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+Fourth and Fifth squads answered, "Wilco"; Ace said, "We're already doin' it — pick up your feet." Red's beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+<p>
+At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I'm no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn't already been told to jump, I guess I wouldn't have got out of there.
+</p>
+
+<p>
+Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+<p>
+There was something on the horizon in the direction of their spaceport — administration & control, maybe, or possibly even a starship. Almost in line and about half as far away was an enormous structure which I couldn't identify even that loosely. The range to the spaceport was extreme but I let the rocket see it, said, "Go find it, baby!" and twisted its tail — slapped the last one in, sent it toward the nearer target, and jumped. That building took a direct hit just as I left it. Either a skinny had judged (correctly) that it was worth one of their buildings to try for one of us, or one of my own mates was getting mighty careless with fireworks. Either way, I didn't want to jump from that spot, even a skimmer; I decided to go through the next couple of buildings instead of over. So I grabbed the heavy flamer off my back as I hit and dipped the snoopers down over my eyes, tackled a wall in front of me with a knife beam at full power. A section of
+wall fell away and I charged in. And backed out even faster. I didn't know what it was I had cracked open. A congregation in church — a skinny flophouse —
+maybe even their defense headquarters. All I knew was that it was a very big room filled with more skinnies than I wanted to see in my whole life.
+</p>
+
+<p>
+Probably not a church, for somebody took a shot at me as I popped back out just a slug that bounced off my armor, made my ears ring, and staggered me without hurting me. But it reminded me that I wasn't supposed to leave without giving them a souvenir of my visit. I grabbed the first thing on my belt and lobbed it in — and heard it start to squawk. As they keep telling you in Basic, doing something constructive at once is better than figuring out the best thing to do hours later. By sheer chance I had done the right thing. This was a special bomb, one each issued to us for this mission with instructions to use them if we found ways to make them effective. The squawking I heard as I threw it was the bomb shouting in skinny talk (free translation): "I'm a thirty-second bomb! I'm a thirty-second bomb! Twenty-nine!... twenty-eight!... twenty-seven! — "It was supposed to frazzle their nerves. Maybe it did; it certainly frazzled mine. Kinder to shoot a man. I didn't wait for the countdown; I jumped, while I wondered whether they would find enough doors and windows to swarm out in time.
+</p>
+
+<p>
+I got a bearing on Red's blinker at the top of the jump and one on Ace as I grounded. I was falling behind again — time to hurry. But three minutes later we had closed the gap; I had Red on my left flank a half mile away. He reported it to Jelly. We heard Jelly's relaxed growl to the entire platoon: "Circle is closed, but the beacon is not down yet. Move forward slowly and mill around, make a little more trouble — but mind the lad on each side of you; don't make trouble for him. Good job, so far — don't spoil it. Platoon! By sections...Muster!"
+</p>
+
+<p>
+It looked like a good job to me, too; much of the city was burning and, although it was almost full light now, it was hard to tell whether bare eyes were better than snoopers, the smoke was so thick. Johnson, our section leader, sounded off: "Second section, call off!" I echoed, "Squads four, five, and six — call off and report!" The assortment of safe circuits we had available in the new model comm units certainly speeded things up; Jelly could talk to anybody or to his section leaders; a section leader could call his whole section, or his non-coms; and the platoon could muster twice as fast, when seconds matter. I listened to the fourth squad call off while I inventoried my remaining firepower and lobbed one bomb toward a skinny who poked his head around a corner. He left and so did I — "Mill around," the boss man had said.
+</p>
+
+<p>
+The fourth squad bumbled the call off until the squad leader remembered to fill in with Jenkins' number; the fifth squad clicked off like an abacus and I began to feel good . . . when the call off stopped after number four in Ace's squad. I called out, "Ace, where's Dizzy?"
+</p>
+
+<p>
+"Shut up," he said. "Number six! Call off!"
+</p>
+
+<p>
+"Six!" Smith answered.
+</p>
+
+<p>
+"Seven!"
+</p>
+
+<p>
+"Sixth squad, Flores missing," Ace completed it. "Squad leader out for pickup."
+</p>
+
+<p>
+"One man absent," I reported to Johnson. "Flores, squad six."
+</p>
+
+<p>
+"Missing or dead?"
+</p>
+
+<p>
+"I don't know. Squad leader and assistant section leader dropping out for pickup."
+</p>
+
+<p>
+"Johnnie, you let Ace take it."
+</p>
+
+<p>
+But I didn't hear him, so I didn't answer. I heard him report to Jelly and I heard Jelly cuss. Now look, I wasn't bucking for a medal — it's the assistant section leader's business to make pickup; he's the chaser, the last man in, expendable. The squad leaders have other work to do. As you've no doubt gathered by now the assistant section leader isn't necessary as long as the section leader is alive. Right that moment I was feeling unusually expendable, almost expended, because I was hearing the sweetest sound in the universe, the beacon the retrieval boat would land on, sounding our recall. The beacon is a robot rocket, fired ahead of the retrieval boat, just a spike that buries itself in the ground and starts broadcasting that welcome, welcome music. The retrieval boat homes in on it automatically three minutes later and you had better be on hand, because the bus can't wait and there won't be another one along.
+</p>
+
+<p>
+But you don't walk away on another cap trooper, not while there's a chance he's still alive — not in Rasczak's Roughnecks. Not in any outfit of the Mobile Infantry. You try to make pickup. I heard Jelly order: "Heads up, lads! Close to retrieval circle and interdict! On the bounce!"
+</p>
+
+<p>
+And I heard the beacon's sweet voice: " — to the everlasting glory of the infantry, shines the name, shines the name of Rodger Young!" and I wanted to head for it so bad I could taste it.
+</p>
+
+<p>
+Instead I was headed the other way, closing on Ace's beacon and expending what I had left of bombs and fire pills and anything else that would weigh me down. "Ace! You got his beacon?"
+</p>
+
+<p>
+"Yes. Go back, Useless!"
+</p>
+
+<p>
+"I've got you by eye now. Where is he?"
+</p>
+
+<p>
+"Right ahead of me, maybe quarter mile. Scram! He's my man ."
+</p>
+
+<p>
+I didn't answer; I simply cut left oblique to reach Ace about where he said Dizzy was.
+</p>
+
+<p>
+And found Ace standing over him, a couple of skinnies flamed down and more running away. I lit beside him. "Let's get him out of his armor — the boat'll be down any second!"
+</p>
+
+<p>
+"He's too bad hurt!"
+</p>
+
+<p>
+I looked and saw that it was true — there was actually a hole in his armor and blood coming out. And I was stumped. To make a wounded pickup you get him out of his armor... then you simply pick him up in your arms — no trouble in a powered suit — and bounce away from there. A bare man weighs less than the ammo and stuff you've expended. "What'll we do?"
+</p>
+
+<p>
+"We carry him," Ace said grimly. "Grab ahold the left side of his belt." He grabbed the right side, we manhandled Flores to his feet. "Lock on! Now... by the numbers, stand by to jump — one — two!"
+</p>
+
+<p>
+We jumped. Not far, not well. One man alone couldn't have gotten him off the ground; an armored suit is too heavy. But split it between two men and it can be done.
+We jumped — and we jumped — and again, and again, with Ace calling it and both of us steadying and catching Dizzy on each grounding. His gyros seemed to be out.
+</p>
+
+<p>
+We heard the beacon cut off as the retrieval boat landed on it — I saw it land . . . and it was too far away. We heard the acting platoon sergeant call out: "In succession, prepare to embark!"
+</p>
+
+<p>
+And Jelly called out, "Belay that order!"
+</p>
+
+<p>
+We broke at last into the open and saw the boat standing on its tail, heard the ululation of its take-off warning — saw the platoon still on the ground around it, in interdiction circle, crouching behind the shield they had formed. Heard Jelly shout, "In succession, man the boat — move!"
+</p>
+
+<p>
+And we were still too far away! I could see them peel off from the first squad, swarm into the boat as the interdiction circle tightened. And a single figure broke out of the circle, came toward us at a speed possible only to a command suit. Jelly caught us while we were in the air, grabbed Flores by his Y-rack and helped us lift. Three jumps got us to the boat. Everybody else was inside but the door was still open. We got him in and closed it while the boat pilot screamed that we had made her miss rendezvous and now we had all bought it! Jelly paid no attention to her; we laid Flores down and lay down beside him. As the blast hit us Jelly was saying to himself, "All present, Lieutenant. Three men hurt — but all present!"
+</p>
+
+<p>
+I'll say this for Captain Deladrier: they don't make any better pilots. A rendezvous, boat to ship in orbit, is precisely calculated. I don't know how, but it is, and you don't change it. You can't.
+</p>
+
+<p>
+Only she did. She saw in her scope that the boat had failed to blast on time; she braked back, picked up speed again — and matched and took us in, just by eye and touch, no time to compute it. If the Almighty ever needs an assistant to keep the stars in their courses, I know where he can look.
+</p>
+
+<p>
+Flores died on the way up.
+</p>
+
+<p>
+ -- repeat --
+</p>
+
+<p>
+Then suddenly nothing. Nothing at all. No sound, no pressure, no weight. Floating in darkness... free fall, maybe thirty miles up, above the effective atmosphere, falling weightlessly toward the surface of a planet you've never seen. But I'm not shaking now; it's the wait beforehand that wears. Once you unload, you can't get hurt — because if anything goes wrong it will happen so fast that you'll buy it without noticing that you're dead, hardly.
+</p>
+
+<p>
+Almost at once I felt the capsule twist and sway, then steady down so that my weight was on my back...weight that built up quickly until I was at my full weight (0.87 gee, we had been told) for that planet as the capsule reached terminal velocity for the thin upper atmosphere. A pilot who is a real artist (and the Captain was) will approach and brake so that your launching speed as you shoot out of the tube places you just dead in space relative to the rotational speed of the planet at that latitude. The loaded capsules are heavy; they punch through the high, thin winds of the upper atmosphere without being blown too far out of position — but just the same a platoon is bound to disperse on the way down, lose some of the perfect formation in which it unloads. A sloppy pilot can make this still worse, scatter a strike group over so much terrain that it can't make rendezvous for retrieval, much less carry out its mission. An infantryman can fight only if somebody else delivers him to his zone; in a way I suppose pilots are just as essential as we are.
+</p>
+
+<p>
+I could tell from the gentle way my capsule entered the atmosphere that the Captain had laid us down with as near zero lateral vector as you could ask for. I felt happy — not only a tight formation when we hit and no time wasted, but also a pilot who puts you down properly is a pilot who is smart and precise on retrieval.
+</p>
+
+<p>
+The outer shell burned away and sloughed off — unevenly, for I tumbled. Then the rest of it went and I straightened out. The turbulence brakes of the second shell bit in and the ride got rough... and still rougher as they burned off one at a time and the second shell began to go to pieces. One of the things that helps a capsule trooper to live long enough to draw a pension is that the skins peeling off his capsule not only slow him down, they also fill the sky over the target area with so much junk that radar picks up reflections from dozens of targets for each man in the drop, any one of which could be a man, or a bomb, or anything. It's enough to give a ballistic computer nervous breakdowns — and does. To add to the fun your ship lays a series of dummy eggs in the seconds immediately following your drop, dummies that will fall faster because they don't slough. They get under you, explode, throw out "window," even operate as transponders, rocket sideways, and do other things to add to the confusion of your reception committee on the ground.
+</p>
+
+<p>
+In the meantime your ship is locked firmly on the directional beacon of your platoon leader, ignoring the radar "noise" it has created and following you in, computing your impact for future use. When the second shell was gone, the third shell automatically opened my first ribbon chute. It didn't last long but it wasn't expected to; one good, hard jerk at several gee and it went its way and I went mine. The second chute lasted a little bit longer and the third chute lasted quite a while; it began to be rather too warm inside the capsule and I started thinking about landing.
+</p>
+
+<p>
+The third shell peeled off when its last chute was gone and now I had nothing around me but my suit armor and a plastic egg. I was still strapped inside it, unable to move; it was time to decide how and where I was going to ground. Without moving my arms (I couldn't) I thumbed the switch for a proximity reading and read it when it flashed on in the instrument reflector inside my helmet in front of my forehead. A mile and eight-tenths — A little closer than I liked, especially without company. The inner egg had reached steady speed, no more help to be gained by staying inside it, and its skin temperature indicated that it would not open automatically for a while yet — so I flipped a switch with my other thumb and got rid of it.
+</p>
+
+<p>
+The first charge cut all the straps; the second charge exploded the plastic egg away from me in eight separate pieces — and I was outdoors, sitting on air, and could see! Better still, the eight discarded pieces were metal-coated (except for the small bit I had taken proximity reading through) and would give back the same reflection as an armored man. Any radar viewer, alive or cybernetic, would now have a sad time sorting me out from the junk nearest me, not to mention the thousands of other bits and pieces for miles on each side, above, and below me. Part of a mobile infantryman's training is to let him see, from the ground and both by eye and by radar, just how confusing a drop is to the forces on the ground — because you feel awful naked up there. It is easy to panic and either open a chute too soon and become a sitting duck (do ducks really sit? — if so, why?) or fail to open it and break your ankles, likewise backbone and skull. So I stretched, getting the kinks out, and looked around... then doubled up again and straightened out in a swan dive face down and took a good look. It was night down there, as planned, but infrared snoopers let you size up terrain quite well after you are used to them. The river that cut diagonally through the city was almost below me and coming up fast, shining out clearly with a higher temperature than the land. I didn't care which side of it I landed on but I didn't want to land in it; it would slow me down.
+</p>
+
+<p>
+I noticed a dash off to the right at about my altitude; some unfriendly native down below had burned what was probably a piece of my egg. So I fired my first chute at once, intending if possible to jerk myself right off his screen as he followed the targets down in closing range. I braced for the shock, rode it, then floated down for about twenty seconds before unloading the chute — not wishing to call attention to myself in still another way by not falling at the speed of the other stuff around me. It must have worked; I wasn't burned.
+</p>
+
+<p>
+About six hundred feet up I shot the second chute... saw very quickly that I was being carried over into the river, found that I was going to pass about a hundred feet up over a flat-roofed warehouse or some such by the river... blew the chute free and came in for a good enough if rather bouncy landing on the roof by means of the suit's jump jets. I was scanning for Sergeant Jelal's beacon as I hit. And found that I was on the wrong side of the river; Jelly's star showed up on the compass ring inside my helmet far south of where it should have been — I was too far north. I trotted toward the river side of the roof as I took a range and bearing on the squad leader next to me, found that he was over a mile out of position, called, "Ace! dress your line," tossed a bomb behind me as I stepped off the building and across the river. Ace answered as I could have expected — Ace should have had my spot but he didn't want to give up his squad; nevertheless he didn't fancy taking orders from me.
+</p>
+
+<p>
+The warehouse went up behind me and the blast hit me while I was still over the river, instead of being shielded by the buildings on the far side as I should have been. It darn near tumbled my gyros and I came close to tumbling myself. I had set that bomb for fifteen seconds... or had I? I suddenly realized that I had let myself get excited, the worst thing you can do once you're on the ground. "Just like a drill," that was the way, just as Jelly had warned me. Take your time and do it right, even if it takes another half second. As I hit I took another reading on Ace and told him again to realign his squad. He didn't answer but he was already doing it. I let it ride. As long as Ace did his job, I could afford to swallow his surliness — for now. But back aboard ship (if Jelly kept me on as assistant section leader) we would eventually have to pick a quiet spot and find out who was boss. He was a career corporal and I was just a term lance acting as corporal, but he was under me and you can't afford to take any lip under those circumstances. Not permanently.
+</p>
+
+<p>
+But I didn't have time then to think about it; while I was jumping the river I had spotted a juicy target and I wanted to get it before somebody else noticed it — a lovely big group of what looked like public buildings on a hill. Temples, maybe... or a palace. They were miles outside the area we were sweeping, but one rule of a smash & run is to expend at least half your ammo outside your sweep area; that way the enemy is kept confused as to where you actually are — that and keep moving, do everything fast. You're always heavily outnumbered; surprise and speed are what saves you. I was already loading my rocket launcher while I was checking on Ace and telling him for the second time to straighten up. Jelly's voice reached me right on top of that on the all-hands circuit: "Platoon! By leapfrog! Forward!" My boss, Sergeant Johnson, echoed, "By leapfrog! Odd numbers! Advance!" That left me with nothing to worry about for twenty seconds, so I jumped up on the building nearest me, raised the launcher to my shoulder, found the target and pulled the first trigger to let the rocket have a look at its target — pulled the second trigger and kissed it on its way, jumped back to the ground. "Second section, even numbers!" I called out... waited for the count in my mind and ordered, "Advance!"
+</p>
+
+<p>
+And did so myself, hopping over the next row of buildings, and, while I was in the air, fanning the first row by the river front with a hand flamer. They seemed to be wood construction and it looked like time to start a good fire — with luck, some of those warehouses would house oil products, or even explosives. As I hit, the Y-rack on my shoulders launched two small H. E. bombs a couple of hundred yards each way to my right and left flanks but I never saw what they did as just then my first rocket hit — that unmistakable (if you've ever seen one) brilliance of an atomic explosion. It was just a peewee, of course, less than two kilotons nominal yield, with tamper and implosion squeeze to produce results from a less-than-critical mass — but then who wants to be bunk mates with a cosmic catastrophe? It was enough to clean off that hilltop and make everybody in the city take shelter against fallout. Better still, any of the local yokels who happened to be outdoors and looking that way wouldn't be seeing anything else for a couple of hours — meaning me. The dash hadn't dazzled me, nor would it dazzle any of us; our face bowls are heavily leaded, we wear snoopers over our eyes — and we're trained to duck and take it on the armor if we do happen to be looking the wrong way.
+</p>
+
+<p>
+So I merely blinked hard — opened my eyes and stared straight at a local citizen just coming out of an opening in the building ahead of me. He looked at me, I looked at him, and he started to raise something — a weapon, I suppose — as Jelly called out, "Odd numbers! Advance!"
+</p>
+
+<p>
+I didn't have time to fool with him; I was a good five hundred yards short of where I should have been by then. I still had the hand flamer in my left hand; I toasted him and jumped over the building he had been coming out of, as I started to count. A hand flamer is primarily for incendiary work but it is a good defensive anti-personnel weapon in tight quarters; you don't have to aim it much.
+</p>
+
+<p>
+Between excitement and anxiety to catch up I jumped too high and too wide. It's always a temptation to get the most out of your jump gear — but don't do it! It leaves you hanging in the air for seconds, a big fat target. The way to advance is to skim over each building as you come to it, barely clearing it, and taking full advantage of cover while you're down — and never stay in one place more than a second or two, never give them time to target in on you. Be somewhere else, anywhere. Keep moving.
+</p>
+
+<p>
+</p>
+
+<p>This one I goofed — too much for one row of buildings, too little for the row beyond it; I found myself coming down on a roof. But not a nice flat one where I might have tarried three seconds to launch another peewee A-rocket; this roof was a jungle of pipes and stanchions and assorted ironmongery — a factory maybe, or some sort of chemical works. No place to land. Worse still, half a dozen natives were up there. These geezers are humanoid, eight or nine feet tall, much skinnier than we are and with a higher body temperature; they don't wear any clothes and they stand out in a set of snoopers like a neon sign. They look still funnier in daylight with your bare eyes but I would rather fight them than the arachnids — those Bugs make me queezy.
+</p>
+
+<p>
+If these laddies were up there thirty seconds earlier when my rocket hit, then they couldn't see me, or anything. But I couldn't be certain and didn't want to tangle with them in any case; it wasn't that kind of a raid. So I jumped again while I was still in the air, scattering a handful of ten-second fire pills to keep
+them busy, grounded, jumped again at once, and called out, "Second section! Even numbers!...Advance!" and kept right on going to close the gap, while trying to spot, every time I jumped, something worth expending a rocket on. I had three more of the little A-rockets and I certainly didn't intend to take any back with me.
+</p>
+
+<p>
+But I had had pounded into me that you must get your money's worth with atomic weapons — it was only the second time that I had been allowed to carry them. Right now I was trying to spot their waterworks; a direct hit on it could make the whole city uninhabitable, force them to evacuate it without directly killing anyone — just the sort of nuisance we had been sent down to commit. It should — according to the map we had studied under hypnosis — be about three miles upstream from where I was.
+</p>
+
+<p>
+But I couldn't see it; my jumps didn't take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+Fourth and Fifth squads answered, "Wilco"; Ace said, "We're already doin' it — pick up your feet." Red's beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+<p>
+At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I'm no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn't already been told to jump, I guess I wouldn't have got out of there.
+</p>
+
+<p>
+Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+<p>
+There was something on the horizon in the direction of their spaceport — administration & control, maybe, or possibly even a starship. Almost in line and about half as far away was an enormous structure which I couldn't identify even that loosely. The range to the spaceport was extreme but I let the rocket see it, said, "Go find it, baby!" and twisted its tail — slapped the last one in, sent it toward the nearer target, and jumped. That building took a direct hit just as I left it. Either a skinny had judged (correctly) that it was worth one of their buildings to try for one of us, or one of my own mates was getting mighty careless with fireworks. Either way, I didn't want to jump from that spot, even a skimmer; I decided to go through the next couple of buildings instead of over. So I grabbed the heavy flamer off my back as I hit and dipped the snoopers down over my eyes, tackled a wall in front of me with a knife beam at full power. A section of
+wall fell away and I charged in. And backed out even faster. I didn't know what it was I had cracked open. A congregation in church — a skinny flophouse —
+maybe even their defense headquarters. All I knew was that it was a very big room filled with more skinnies than I wanted to see in my whole life.
+</p>
+
+<p>
+Probably not a church, for somebody took a shot at me as I popped back out just a slug that bounced off my armor, made my ears ring, and staggered me without hurting me. But it reminded me that I wasn't supposed to leave without giving them a souvenir of my visit. I grabbed the first thing on my belt and lobbed it in — and heard it start to squawk. As they keep telling you in Basic, doing something constructive at once is better than figuring out the best thing to do hours later. By sheer chance I had done the right thing. This was a special bomb, one each issued to us for this mission with instructions to use them if we found ways to make them effective. The squawking I heard as I threw it was the bomb shouting in skinny talk (free translation): "I'm a thirty-second bomb! I'm a thirty-second bomb! Twenty-nine!... twenty-eight!... twenty-seven! — "It was supposed to frazzle their nerves. Maybe it did; it certainly frazzled mine. Kinder to shoot a man. I didn't wait for the countdown; I jumped, while I wondered whether they would find enough doors and windows to swarm out in time.
+</p>
+
+<p>
+I got a bearing on Red's blinker at the top of the jump and one on Ace as I grounded. I was falling behind again — time to hurry. But three minutes later we had closed the gap; I had Red on my left flank a half mile away. He reported it to Jelly. We heard Jelly's relaxed growl to the entire platoon: "Circle is closed, but the beacon is not down yet. Move forward slowly and mill around, make a little more trouble — but mind the lad on each side of you; don't make trouble for him. Good job, so far — don't spoil it. Platoon! By sections...Muster!"
+</p>
+
+<p>
+It looked like a good job to me, too; much of the city was burning and, although it was almost full light now, it was hard to tell whether bare eyes were better than snoopers, the smoke was so thick. Johnson, our section leader, sounded off: "Second section, call off!" I echoed, "Squads four, five, and six — call off and report!" The assortment of safe circuits we had available in the new model comm units certainly speeded things up; Jelly could talk to anybody or to his section leaders; a section leader could call his whole section, or his non-coms; and the platoon could muster twice as fast, when seconds matter. I listened to the fourth squad call off while I inventoried my remaining firepower and lobbed one bomb toward a skinny who poked his head around a corner. He left and so did I — "Mill around," the boss man had said.
+</p>
+
+<p>
+The fourth squad bumbled the call off until the squad leader remembered to fill in with Jenkins' number; the fifth squad clicked off like an abacus and I began to feel good . . . when the call off stopped after number four in Ace's squad. I called out, "Ace, where's Dizzy?"
+</p>
+
+<p>
+"Shut up," he said. "Number six! Call off!"
+</p>
+
+<p>
+"Six!" Smith answered.
+</p>
+
+<p>
+"Seven!"
+</p>
+
+<p>
+"Sixth squad, Flores missing," Ace completed it. "Squad leader out for pickup."
+</p>
+
+<p>
+"One man absent," I reported to Johnson. "Flores, squad six."
+</p>
+
+<p>
+"Missing or dead?"
+</p>
+
+<p>
+"I don't know. Squad leader and assistant section leader dropping out for pickup."
+</p>
+
+<p>
+"Johnnie, you let Ace take it."
+</p>
+
+<p>
+But I didn't hear him, so I didn't answer. I heard him report to Jelly and I heard Jelly cuss. Now look, I wasn't bucking for a medal — it's the assistant section leader's business to make pickup; he's the chaser, the last man in, expendable. The squad leaders have other work to do. As you've no doubt gathered by now the assistant section leader isn't necessary as long as the section leader is alive. Right that moment I was feeling unusually expendable, almost expended, because I was hearing the sweetest sound in the universe, the beacon the retrieval boat would land on, sounding our recall. The beacon is a robot rocket, fired ahead of the retrieval boat, just a spike that buries itself in the ground and starts broadcasting that welcome, welcome music. The retrieval boat homes in on it automatically three minutes later and you had better be on hand, because the bus can't wait and there won't be another one along.
+</p>
+
+<p>
+But you don't walk away on another cap trooper, not while there's a chance he's still alive — not in Rasczak's Roughnecks. Not in any outfit of the Mobile Infantry. You try to make pickup. I heard Jelly order: "Heads up, lads! Close to retrieval circle and interdict! On the bounce!"
+</p>
+
+<p>
+And I heard the beacon's sweet voice: " — to the everlasting glory of the infantry, shines the name, shines the name of Rodger Young!" and I wanted to head for it so bad I could taste it.
+</p>
+
+<p>
+Instead I was headed the other way, closing on Ace's beacon and expending what I had left of bombs and fire pills and anything else that would weigh me down. "Ace! You got his beacon?"
+</p>
+
+<p>
+"Yes. Go back, Useless!"
+</p>
+
+<p>
+"I've got you by eye now. Where is he?"
+</p>
+
+<p>
+"Right ahead of me, maybe quarter mile. Scram! He's my man ."
+</p>
+
+<p>
+I didn't answer; I simply cut left oblique to reach Ace about where he said Dizzy was.
+</p>
+
+<p>
+And found Ace standing over him, a couple of skinnies flamed down and more running away. I lit beside him. "Let's get him out of his armor — the boat'll be down any second!"
+</p>
+
+<p>
+"He's too bad hurt!"
+</p>
+
+<p>
+I looked and saw that it was true — there was actually a hole in his armor and blood coming out. And I was stumped. To make a wounded pickup you get him out of his armor... then you simply pick him up in your arms — no trouble in a powered suit — and bounce away from there. A bare man weighs less than the ammo and stuff you've expended. "What'll we do?"
+</p>
+
+<p>
+"We carry him," Ace said grimly. "Grab ahold the left side of his belt." He grabbed the right side, we manhandled Flores to his feet. "Lock on! Now... by the numbers, stand by to jump — one — two!"
+</p>
+
+<p>
+We jumped. Not far, not well. One man alone couldn't have gotten him off the ground; an armored suit is too heavy. But split it between two men and it can be done.
+We jumped — and we jumped — and again, and again, with Ace calling it and both of us steadying and catching Dizzy on each grounding. His gyros seemed to be out.
+</p>
+
+<p>
+We heard the beacon cut off as the retrieval boat landed on it — I saw it land . . . and it was too far away. We heard the acting platoon sergeant call out: "In succession, prepare to embark!"
+</p>
+
+<p>
+And Jelly called out, "Belay that order!"
+</p>
+
+<p>
+We broke at last into the open and saw the boat standing on its tail, heard the ululation of its take-off warning — saw the platoon still on the ground around it, in interdiction circle, crouching behind the shield they had formed. Heard Jelly shout, "In succession, man the boat — move!"
+</p>
+
+<p>
+And we were still too far away! I could see them peel off from the first squad, swarm into the boat as the interdiction circle tightened. And a single figure broke out of the circle, came toward us at a speed possible only to a command suit. Jelly caught us while we were in the air, grabbed Flores by his Y-rack and helped us lift. Three jumps got us to the boat. Everybody else was inside but the door was still open. We got him in and closed it while the boat pilot screamed that we had made her miss rendezvous and now we had all bought it! Jelly paid no attention to her; we laid Flores down and lay down beside him. As the blast hit us Jelly was saying to himself, "All present, Lieutenant. Three men hurt — but all present!"
+</p>
+
+<p>
+I'll say this for Captain Deladrier: they don't make any better pilots. A rendezvous, boat to ship in orbit, is precisely calculated. I don't know how, but it is, and you don't change it. You can't.
+</p>
+
+<p>
+Only she did. She saw in her scope that the boat had failed to blast on time; she braked back, picked up speed again — and matched and took us in, just by eye and touch, no time to compute it. If the Almighty ever needs an assistant to keep the stars in their courses, I know where he can look.
+</p>
+
+<p>
+Flores died on the way up.
+</p>
+
+<p>
+ -- repeat --
+</p>
+
+<p>
+Then suddenly nothing. Nothing at all. No sound, no pressure, no weight. Floating in darkness... free fall, maybe thirty miles up, above the effective atmosphere, falling weightlessly toward the surface of a planet you've never seen. But I'm not shaking now; it's the wait beforehand that wears. Once you unload, you can't get hurt — because if anything goes wrong it will happen so fast that you'll buy it without noticing that you're dead, hardly.
+</p>
+
+<p>
+Almost at once I felt the capsule twist and sway, then steady down so that my weight was on my back...weight that built up quickly until I was at my full weight (0.87 gee, we had been told) for that planet as the capsule reached terminal velocity for the thin upper atmosphere. A pilot who is a real artist (and the Captain was) will approach and brake so that your launching speed as you shoot out of the tube places you just dead in space relative to the rotational speed of the planet at that latitude. The loaded capsules are heavy; they punch through the high, thin winds of the upper atmosphere without being blown too far out of position — but just the same a platoon is bound to disperse on the way down, lose some of the perfect formation in which it unloads. A sloppy pilot can make this still worse, scatter a strike group over so much terrain that it can't make rendezvous for retrieval, much less carry out its mission. An infantryman can fight only if somebody else delivers him to his zone; in a way I suppose pilots are just as essential as we are.
+</p>
+
+<p>
+I could tell from the gentle way my capsule entered the atmosphere that the Captain had laid us down with as near zero lateral vector as you could ask for. I felt happy — not only a tight formation when we hit and no time wasted, but also a pilot who puts you down properly is a pilot who is smart and precise on retrieval.
+</p>
+
+<p>
+The outer shell burned away and sloughed off — unevenly, for I tumbled. Then the rest of it went and I straightened out. The turbulence brakes of the second shell bit in and the ride got rough... and still rougher as they burned off one at a time and the second shell began to go to pieces. One of the things that helps a capsule trooper to live long enough to draw a pension is that the skins peeling off his capsule not only slow him down, they also fill the sky over the target area with so much junk that radar picks up reflections from dozens of targets for each man in the drop, any one of which could be a man, or a bomb, or anything. It's enough to give a ballistic computer nervous breakdowns — and does. To add to the fun your ship lays a series of dummy eggs in the seconds immediately following your drop, dummies that will fall faster because they don't slough. They get under you, explode, throw out "window," even operate as transponders, rocket sideways, and do other things to add to the confusion of your reception committee on the ground.
+</p>
+
+<p>
+In the meantime your ship is locked firmly on the directional beacon of your platoon leader, ignoring the radar "noise" it has created and following you in, computing your impact for future use. When the second shell was gone, the third shell automatically opened my first ribbon chute. It didn't last long but it wasn't expected to; one good, hard jerk at several gee and it went its way and I went mine. The second chute lasted a little bit longer and the third chute lasted quite a while; it began to be rather too warm inside the capsule and I started thinking about landing.
+</p>
+
+<p>
+The third shell peeled off when its last chute was gone and now I had nothing around me but my suit armor and a plastic egg. I was still strapped inside it, unable to move; it was time to decide how and where I was going to ground. Without moving my arms (I couldn't) I thumbed the switch for a proximity reading and read it when it flashed on in the instrument reflector inside my helmet in front of my forehead. A mile and eight-tenths — A little closer than I liked, especially without company. The inner egg had reached steady speed, no more help to be gained by staying inside it, and its skin temperature indicated that it would not open automatically for a while yet — so I flipped a switch with my other thumb and got rid of it.
+</p>
+
+<p>
+The first charge cut all the straps; the second charge exploded the plastic egg away from me in eight separate pieces — and I was outdoors, sitting on air, and could see! Better still, the eight discarded pieces were metal-coated (except for the small bit I had taken proximity reading through) and would give back the same reflection as an armored man. Any radar viewer, alive or cybernetic, would now have a sad time sorting me out from the junk nearest me, not to mention the thousands of other bits and pieces for miles on each side, above, and below me. Part of a mobile infantryman's training is to let him see, from the ground and both by eye and by radar, just how confusing a drop is to the forces on the ground — because you feel awful naked up there. It is easy to panic and either open a chute too soon and become a sitting duck (do ducks really sit? — if so, why?) or fail to open it and break your ankles, likewise backbone and skull. So I stretched, getting the kinks out, and looked around... then doubled up again and straightened out in a swan dive face down and took a good look. It was night down there, as planned, but infrared snoopers let you size up terrain quite well after you are used to them. The river that cut diagonally through the city was almost below me and coming up fast, shining out clearly with a higher temperature than the land. I didn't care which side of it I landed on but I didn't want to land in it; it would slow me down.
+</p>
+
+<p>
+I noticed a dash off to the right at about my altitude; some unfriendly native down below had burned what was probably a piece of my egg. So I fired my first chute at once, intending if possible to jerk myself right off his screen as he followed the targets down in closing range. I braced for the shock, rode it, then floated down for about twenty seconds before unloading the chute — not wishing to call attention to myself in still another way by not falling at the speed of the other stuff around me. It must have worked; I wasn't burned.
+</p>
+
+<p>
+About six hundred feet up I shot the second chute... saw very quickly that I was being carried over into the river, found that I was going to pass about a hundred feet up over a flat-roofed warehouse or some such by the river... blew the chute free and came in for a good enough if rather bouncy landing on the roof by means of the suit's jump jets. I was scanning for Sergeant Jelal's beacon as I hit. And found that I was on the wrong side of the river; Jelly's star showed up on the compass ring inside my helmet far south of where it should have been — I was too far north. I trotted toward the river side of the roof as I took a range and bearing on the squad leader next to me, found that he was over a mile out of position, called, "Ace! dress your line," tossed a bomb behind me as I stepped off the building and across the river. Ace answered as I could have expected — Ace should have had my spot but he didn't want to give up his squad; nevertheless he didn't fancy taking orders from me.
+</p>
+
+<p>
+The warehouse went up behind me and the blast hit me while I was still over the river, instead of being shielded by the buildings on the far side as I should have been. It darn near tumbled my gyros and I came close to tumbling myself. I had set that bomb for fifteen seconds... or had I? I suddenly realized that I had let myself get excited, the worst thing you can do once you're on the ground. "Just like a drill," that was the way, just as Jelly had warned me. Take your time and do it right, even if it takes another half second. As I hit I took another reading on Ace and told him again to realign his squad. He didn't answer but he was already doing it. I let it ride. As long as Ace did his job, I could afford to swallow his surliness — for now. But back aboard ship (if Jelly kept me on as assistant section leader) we would eventually have to pick a quiet spot and find out who was boss. He was a career corporal and I was just a term lance acting as corporal, but he was under me and you can't afford to take any lip under those circumstances. Not permanently.
+</p>
+
+<p>
+But I didn't have time then to think about it; while I was jumping the river I had spotted a juicy target and I wanted to get it before somebody else noticed it — a lovely big group of what looked like public buildings on a hill. Temples, maybe... or a palace. They were miles outside the area we were sweeping, but one rule of a smash & run is to expend at least half your ammo outside your sweep area; that way the enemy is kept confused as to where you actually are — that and keep moving, do everything fast. You're always heavily outnumbered; surprise and speed are what saves you. I was already loading my rocket launcher while I was checking on Ace and telling him for the second time to straighten up. Jelly's voice reached me right on top of that on the all-hands circuit: "Platoon! By leapfrog! Forward!" My boss, Sergeant Johnson, echoed, "By leapfrog! Odd numbers! Advance!" That left me with nothing to worry about for twenty seconds, so I jumped up on the building nearest me, raised the launcher to my shoulder, found the target and pulled the first trigger to let the rocket have a look at its target — pulled the second trigger and kissed it on its way, jumped back to the ground. "Second section, even numbers!" I called out... waited for the count in my mind and ordered, "Advance!"
+</p>
+
+<p>
+And did so myself, hopping over the next row of buildings, and, while I was in the air, fanning the first row by the river front with a hand flamer. They seemed to be wood construction and it looked like time to start a good fire — with luck, some of those warehouses would house oil products, or even explosives. As I hit, the Y-rack on my shoulders launched two small H. E. bombs a couple of hundred yards each way to my right and left flanks but I never saw what they did as just then my first rocket hit — that unmistakable (if you've ever seen one) brilliance of an atomic explosion. It was just a peewee, of course, less than two kilotons nominal yield, with tamper and implosion squeeze to produce results from a less-than-critical mass — but then who wants to be bunk mates with a cosmic catastrophe? It was enough to clean off that hilltop and make everybody in the city take shelter against fallout. Better still, any of the local yokels who happened to be outdoors and looking that way wouldn't be seeing anything else for a couple of hours — meaning me. The dash hadn't dazzled me, nor would it dazzle any of us; our face bowls are heavily leaded, we wear snoopers over our eyes — and we're trained to duck and take it on the armor if we do happen to be looking the wrong way.
+</p>
+
+<p>
+So I merely blinked hard — opened my eyes and stared straight at a local citizen just coming out of an opening in the building ahead of me. He looked at me, I looked at him, and he started to raise something — a weapon, I suppose — as Jelly called out, "Odd numbers! Advance!"
+</p>
+
+<p>
+I didn't have time to fool with him; I was a good five hundred yards short of where I should have been by then. I still had the hand flamer in my left hand; I toasted him and jumped over the building he had been coming out of, as I started to count. A hand flamer is primarily for incendiary work but it is a good defensive anti-personnel weapon in tight quarters; you don't have to aim it much.
+</p>
+
+<p>
+Between excitement and anxiety to catch up I jumped too high and too wide. It's always a temptation to get the most out of your jump gear — but don't do it! It leaves you hanging in the air for seconds, a big fat target. The way to advance is to skim over each building as you come to it, barely clearing it, and taking full advantage of cover while you're down — and never stay in one place more than a second or two, never give them time to target in on you. Be somewhere else, anywhere. Keep moving.
+</p>
+
+<p>
+</p>
+
+<p>This one I goofed — too much for one row of buildings, too little for the row beyond it; I found myself coming down on a roof. But not a nice flat one where I might have tarried three seconds to launch another peewee A-rocket; this roof was a jungle of pipes and stanchions and assorted ironmongery — a factory maybe, or some sort of chemical works. No place to land. Worse still, half a dozen natives were up there. These geezers are humanoid, eight or nine feet tall, much skinnier than we are and with a higher body temperature; they don't wear any clothes and they stand out in a set of snoopers like a neon sign. They look still funnier in daylight with your bare eyes but I would rather fight them than the arachnids — those Bugs make me queezy.
+</p>
+
+<p>
+If these laddies were up there thirty seconds earlier when my rocket hit, then they couldn't see me, or anything. But I couldn't be certain and didn't want to tangle with them in any case; it wasn't that kind of a raid. So I jumped again while I was still in the air, scattering a handful of ten-second fire pills to keep
+them busy, grounded, jumped again at once, and called out, "Second section! Even numbers!...Advance!" and kept right on going to close the gap, while trying to spot, every time I jumped, something worth expending a rocket on. I had three more of the little A-rockets and I certainly didn't intend to take any back with me.
+</p>
+
+<p>
+But I had had pounded into me that you must get your money's worth with atomic weapons — it was only the second time that I had been allowed to carry them. Right now I was trying to spot their waterworks; a direct hit on it could make the whole city uninhabitable, force them to evacuate it without directly killing anyone — just the sort of nuisance we had been sent down to commit. It should — according to the map we had studied under hypnosis — be about three miles upstream from where I was.
+</p>
+
+<p>
+But I couldn't see it; my jumps didn't take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+Fourth and Fifth squads answered, "Wilco"; Ace said, "We're already doin' it — pick up your feet." Red's beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+<p>
+At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I'm no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn't already been told to jump, I guess I wouldn't have got out of there.
+</p>
+
+<p>
+Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+<p>
+There was something on the horizon in the direction of their spaceport — administration & control, maybe, or possibly even a starship. Almost in line and about half as far away was an enormous structure which I couldn't identify even that loosely. The range to the spaceport was extreme but I let the rocket see it, said, "Go find it, baby!" and twisted its tail — slapped the last one in, sent it toward the nearer target, and jumped. That building took a direct hit just as I left it. Either a skinny had judged (correctly) that it was worth one of their buildings to try for one of us, or one of my own mates was getting mighty careless with fireworks. Either way, I didn't want to jump from that spot, even a skimmer; I decided to go through the next couple of buildings instead of over. So I grabbed the heavy flamer off my back as I hit and dipped the snoopers down over my eyes, tackled a wall in front of me with a knife beam at full power. A section of
+wall fell away and I charged in. And backed out even faster. I didn't know what it was I had cracked open. A congregation in church — a skinny flophouse —
+maybe even their defense headquarters. All I knew was that it was a very big room filled with more skinnies than I wanted to see in my whole life.
+</p>
+
+<p>
+Probably not a church, for somebody took a shot at me as I popped back out just a slug that bounced off my armor, made my ears ring, and staggered me without hurting me. But it reminded me that I wasn't supposed to leave without giving them a souvenir of my visit. I grabbed the first thing on my belt and lobbed it in — and heard it start to squawk. As they keep telling you in Basic, doing something constructive at once is better than figuring out the best thing to do hours later. By sheer chance I had done the right thing. This was a special bomb, one each issued to us for this mission with instructions to use them if we found ways to make them effective. The squawking I heard as I threw it was the bomb shouting in skinny talk (free translation): "I'm a thirty-second bomb! I'm a thirty-second bomb! Twenty-nine!... twenty-eight!... twenty-seven! — "It was supposed to frazzle their nerves. Maybe it did; it certainly frazzled mine. Kinder to shoot a man. I didn't wait for the countdown; I jumped, while I wondered whether they would find enough doors and windows to swarm out in time.
+</p>
+
+<p>
+I got a bearing on Red's blinker at the top of the jump and one on Ace as I grounded. I was falling behind again — time to hurry. But three minutes later we had closed the gap; I had Red on my left flank a half mile away. He reported it to Jelly. We heard Jelly's relaxed growl to the entire platoon: "Circle is closed, but the beacon is not down yet. Move forward slowly and mill around, make a little more trouble — but mind the lad on each side of you; don't make trouble for him. Good job, so far — don't spoil it. Platoon! By sections...Muster!"
+</p>
+
+<p>
+It looked like a good job to me, too; much of the city was burning and, although it was almost full light now, it was hard to tell whether bare eyes were better than snoopers, the smoke was so thick. Johnson, our section leader, sounded off: "Second section, call off!" I echoed, "Squads four, five, and six — call off and report!" The assortment of safe circuits we had available in the new model comm units certainly speeded things up; Jelly could talk to anybody or to his section leaders; a section leader could call his whole section, or his non-coms; and the platoon could muster twice as fast, when seconds matter. I listened to the fourth squad call off while I inventoried my remaining firepower and lobbed one bomb toward a skinny who poked his head around a corner. He left and so did I — "Mill around," the boss man had said.
+</p>
+
+<p>
+The fourth squad bumbled the call off until the squad leader remembered to fill in with Jenkins' number; the fifth squad clicked off like an abacus and I began to feel good . . . when the call off stopped after number four in Ace's squad. I called out, "Ace, where's Dizzy?"
+</p>
+
+<p>
+"Shut up," he said. "Number six! Call off!"
+</p>
+
+<p>
+"Six!" Smith answered.
+</p>
+
+<p>
+"Seven!"
+</p>
+
+<p>
+"Sixth squad, Flores missing," Ace completed it. "Squad leader out for pickup."
+</p>
+
+<p>
+"One man absent," I reported to Johnson. "Flores, squad six."
+</p>
+
+<p>
+"Missing or dead?"
+</p>
+
+<p>
+"I don't know. Squad leader and assistant section leader dropping out for pickup."
+</p>
+
+<p>
+"Johnnie, you let Ace take it."
+</p>
+
+<p>
+But I didn't hear him, so I didn't answer. I heard him report to Jelly and I heard Jelly cuss. Now look, I wasn't bucking for a medal — it's the assistant section leader's business to make pickup; he's the chaser, the last man in, expendable. The squad leaders have other work to do. As you've no doubt gathered by now the assistant section leader isn't necessary as long as the section leader is alive. Right that moment I was feeling unusually expendable, almost expended, because I was hearing the sweetest sound in the universe, the beacon the retrieval boat would land on, sounding our recall. The beacon is a robot rocket, fired ahead of the retrieval boat, just a spike that buries itself in the ground and starts broadcasting that welcome, welcome music. The retrieval boat homes in on it automatically three minutes later and you had better be on hand, because the bus can't wait and there won't be another one along.
+</p>
+
+<p>
+But you don't walk away on another cap trooper, not while there's a chance he's still alive — not in Rasczak's Roughnecks. Not in any outfit of the Mobile Infantry. You try to make pickup. I heard Jelly order: "Heads up, lads! Close to retrieval circle and interdict! On the bounce!"
+</p>
+
+<p>
+And I heard the beacon's sweet voice: " — to the everlasting glory of the infantry, shines the name, shines the name of Rodger Young!" and I wanted to head for it so bad I could taste it.
+</p>
+
+<p>
+Instead I was headed the other way, closing on Ace's beacon and expending what I had left of bombs and fire pills and anything else that would weigh me down. "Ace! You got his beacon?"
+</p>
+
+<p>
+"Yes. Go back, Useless!"
+</p>
+
+<p>
+"I've got you by eye now. Where is he?"
+</p>
+
+<p>
+"Right ahead of me, maybe quarter mile. Scram! He's my man ."
+</p>
+
+<p>
+I didn't answer; I simply cut left oblique to reach Ace about where he said Dizzy was.
+</p>
+
+<p>
+And found Ace standing over him, a couple of skinnies flamed down and more running away. I lit beside him. "Let's get him out of his armor — the boat'll be down any second!"
+</p>
+
+<p>
+"He's too bad hurt!"
+</p>
+
+<p>
+I looked and saw that it was true — there was actually a hole in his armor and blood coming out. And I was stumped. To make a wounded pickup you get him out of his armor... then you simply pick him up in your arms — no trouble in a powered suit — and bounce away from there. A bare man weighs less than the ammo and stuff you've expended. "What'll we do?"
+</p>
+
+<p>
+"We carry him," Ace said grimly. "Grab ahold the left side of his belt." He grabbed the right side, we manhandled Flores to his feet. "Lock on! Now... by the numbers, stand by to jump — one — two!"
+</p>
+
+<p>
+We jumped. Not far, not well. One man alone couldn't have gotten him off the ground; an armored suit is too heavy. But split it between two men and it can be done.
+We jumped — and we jumped — and again, and again, with Ace calling it and both of us steadying and catching Dizzy on each grounding. His gyros seemed to be out.
+</p>
+
+<p>
+We heard the beacon cut off as the retrieval boat landed on it — I saw it land . . . and it was too far away. We heard the acting platoon sergeant call out: "In succession, prepare to embark!"
+</p>
+
+<p>
+And Jelly called out, "Belay that order!"
+</p>
+
+<p>
+We broke at last into the open and saw the boat standing on its tail, heard the ululation of its take-off warning — saw the platoon still on the ground around it, in interdiction circle, crouching behind the shield they had formed. Heard Jelly shout, "In succession, man the boat — move!"
+</p>
+
+<p>
+And we were still too far away! I could see them peel off from the first squad, swarm into the boat as the interdiction circle tightened. And a single figure broke out of the circle, came toward us at a speed possible only to a command suit. Jelly caught us while we were in the air, grabbed Flores by his Y-rack and helped us lift. Three jumps got us to the boat. Everybody else was inside but the door was still open. We got him in and closed it while the boat pilot screamed that we had made her miss rendezvous and now we had all bought it! Jelly paid no attention to her; we laid Flores down and lay down beside him. As the blast hit us Jelly was saying to himself, "All present, Lieutenant. Three men hurt — but all present!"
+</p>
+
+<p>
+I'll say this for Captain Deladrier: they don't make any better pilots. A rendezvous, boat to ship in orbit, is precisely calculated. I don't know how, but it is, and you don't change it. You can't.
+</p>
+
+<p>
+Only she did. She saw in her scope that the boat had failed to blast on time; she braked back, picked up speed again — and matched and took us in, just by eye and touch, no time to compute it. If the Almighty ever needs an assistant to keep the stars in their courses, I know where he can look.
+</p>
+
+<p>
+Flores died on the way up.
+</p>
+
+<p>
+ -- repeat --
+</p>
+
+<p>
+Then suddenly nothing. Nothing at all. No sound, no pressure, no weight. Floating in darkness... free fall, maybe thirty miles up, above the effective atmosphere, falling weightlessly toward the surface of a planet you've never seen. But I'm not shaking now; it's the wait beforehand that wears. Once you unload, you can't get hurt — because if anything goes wrong it will happen so fast that you'll buy it without noticing that you're dead, hardly.
+</p>
+
+<p>
+Almost at once I felt the capsule twist and sway, then steady down so that my weight was on my back...weight that built up quickly until I was at my full weight (0.87 gee, we had been told) for that planet as the capsule reached terminal velocity for the thin upper atmosphere. A pilot who is a real artist (and the Captain was) will approach and brake so that your launching speed as you shoot out of the tube places you just dead in space relative to the rotational speed of the planet at that latitude. The loaded capsules are heavy; they punch through the high, thin winds of the upper atmosphere without being blown too far out of position — but just the same a platoon is bound to disperse on the way down, lose some of the perfect formation in which it unloads. A sloppy pilot can make this still worse, scatter a strike group over so much terrain that it can't make rendezvous for retrieval, much less carry out its mission. An infantryman can fight only if somebody else delivers him to his zone; in a way I suppose pilots are just as essential as we are.
+</p>
+
+<p>
+I could tell from the gentle way my capsule entered the atmosphere that the Captain had laid us down with as near zero lateral vector as you could ask for. I felt happy — not only a tight formation when we hit and no time wasted, but also a pilot who puts you down properly is a pilot who is smart and precise on retrieval.
+</p>
+
+<p>
+The outer shell burned away and sloughed off — unevenly, for I tumbled. Then the rest of it went and I straightened out. The turbulence brakes of the second shell bit in and the ride got rough... and still rougher as they burned off one at a time and the second shell began to go to pieces. One of the things that helps a capsule trooper to live long enough to draw a pension is that the skins peeling off his capsule not only slow him down, they also fill the sky over the target area with so much junk that radar picks up reflections from dozens of targets for each man in the drop, any one of which could be a man, or a bomb, or anything. It's enough to give a ballistic computer nervous breakdowns — and does. To add to the fun your ship lays a series of dummy eggs in the seconds immediately following your drop, dummies that will fall faster because they don't slough. They get under you, explode, throw out "window," even operate as transponders, rocket sideways, and do other things to add to the confusion of your reception committee on the ground.
+</p>
+
+<p>
+In the meantime your ship is locked firmly on the directional beacon of your platoon leader, ignoring the radar "noise" it has created and following you in, computing your impact for future use. When the second shell was gone, the third shell automatically opened my first ribbon chute. It didn't last long but it wasn't expected to; one good, hard jerk at several gee and it went its way and I went mine. The second chute lasted a little bit longer and the third chute lasted quite a while; it began to be rather too warm inside the capsule and I started thinking about landing.
+</p>
+
+<p>
+The third shell peeled off when its last chute was gone and now I had nothing around me but my suit armor and a plastic egg. I was still strapped inside it, unable to move; it was time to decide how and where I was going to ground. Without moving my arms (I couldn't) I thumbed the switch for a proximity reading and read it when it flashed on in the instrument reflector inside my helmet in front of my forehead. A mile and eight-tenths — A little closer than I liked, especially without company. The inner egg had reached steady speed, no more help to be gained by staying inside it, and its skin temperature indicated that it would not open automatically for a while yet — so I flipped a switch with my other thumb and got rid of it.
+</p>
+
+<p>
+The first charge cut all the straps; the second charge exploded the plastic egg away from me in eight separate pieces — and I was outdoors, sitting on air, and could see! Better still, the eight discarded pieces were metal-coated (except for the small bit I had taken proximity reading through) and would give back the same reflection as an armored man. Any radar viewer, alive or cybernetic, would now have a sad time sorting me out from the junk nearest me, not to mention the thousands of other bits and pieces for miles on each side, above, and below me. Part of a mobile infantryman's training is to let him see, from the ground and both by eye and by radar, just how confusing a drop is to the forces on the ground — because you feel awful naked up there. It is easy to panic and either open a chute too soon and become a sitting duck (do ducks really sit? — if so, why?) or fail to open it and break your ankles, likewise backbone and skull. So I stretched, getting the kinks out, and looked around... then doubled up again and straightened out in a swan dive face down and took a good look. It was night down there, as planned, but infrared snoopers let you size up terrain quite well after you are used to them. The river that cut diagonally through the city was almost below me and coming up fast, shining out clearly with a higher temperature than the land. I didn't care which side of it I landed on but I didn't want to land in it; it would slow me down.
+</p>
+
+<p>
+I noticed a dash off to the right at about my altitude; some unfriendly native down below had burned what was probably a piece of my egg. So I fired my first chute at once, intending if possible to jerk myself right off his screen as he followed the targets down in closing range. I braced for the shock, rode it, then floated down for about twenty seconds before unloading the chute — not wishing to call attention to myself in still another way by not falling at the speed of the other stuff around me. It must have worked; I wasn't burned.
+</p>
+
+<p>
+About six hundred feet up I shot the second chute... saw very quickly that I was being carried over into the river, found that I was going to pass about a hundred feet up over a flat-roofed warehouse or some such by the river... blew the chute free and came in for a good enough if rather bouncy landing on the roof by means of the suit's jump jets. I was scanning for Sergeant Jelal's beacon as I hit. And found that I was on the wrong side of the river; Jelly's star showed up on the compass ring inside my helmet far south of where it should have been — I was too far north. I trotted toward the river side of the roof as I took a range and bearing on the squad leader next to me, found that he was over a mile out of position, called, "Ace! dress your line," tossed a bomb behind me as I stepped off the building and across the river. Ace answered as I could have expected — Ace should have had my spot but he didn't want to give up his squad; nevertheless he didn't fancy taking orders from me.
+</p>
+
+<p>
+The warehouse went up behind me and the blast hit me while I was still over the river, instead of being shielded by the buildings on the far side as I should have been. It darn near tumbled my gyros and I came close to tumbling myself. I had set that bomb for fifteen seconds... or had I? I suddenly realized that I had let myself get excited, the worst thing you can do once you're on the ground. "Just like a drill," that was the way, just as Jelly had warned me. Take your time and do it right, even if it takes another half second. As I hit I took another reading on Ace and told him again to realign his squad. He didn't answer but he was already doing it. I let it ride. As long as Ace did his job, I could afford to swallow his surliness — for now. But back aboard ship (if Jelly kept me on as assistant section leader) we would eventually have to pick a quiet spot and find out who was boss. He was a career corporal and I was just a term lance acting as corporal, but he was under me and you can't afford to take any lip under those circumstances. Not permanently.
+</p>
+
+<p>
+But I didn't have time then to think about it; while I was jumping the river I had spotted a juicy target and I wanted to get it before somebody else noticed it — a lovely big group of what looked like public buildings on a hill. Temples, maybe... or a palace. They were miles outside the area we were sweeping, but one rule of a smash & run is to expend at least half your ammo outside your sweep area; that way the enemy is kept confused as to where you actually are — that and keep moving, do everything fast. You're always heavily outnumbered; surprise and speed are what saves you. I was already loading my rocket launcher while I was checking on Ace and telling him for the second time to straighten up. Jelly's voice reached me right on top of that on the all-hands circuit: "Platoon! By leapfrog! Forward!" My boss, Sergeant Johnson, echoed, "By leapfrog! Odd numbers! Advance!" That left me with nothing to worry about for twenty seconds, so I jumped up on the building nearest me, raised the launcher to my shoulder, found the target and pulled the first trigger to let the rocket have a look at its target — pulled the second trigger and kissed it on its way, jumped back to the ground. "Second section, even numbers!" I called out... waited for the count in my mind and ordered, "Advance!"
+</p>
+
+<p>
+And did so myself, hopping over the next row of buildings, and, while I was in the air, fanning the first row by the river front with a hand flamer. They seemed to be wood construction and it looked like time to start a good fire — with luck, some of those warehouses would house oil products, or even explosives. As I hit, the Y-rack on my shoulders launched two small H. E. bombs a couple of hundred yards each way to my right and left flanks but I never saw what they did as just then my first rocket hit — that unmistakable (if you've ever seen one) brilliance of an atomic explosion. It was just a peewee, of course, less than two kilotons nominal yield, with tamper and implosion squeeze to produce results from a less-than-critical mass — but then who wants to be bunk mates with a cosmic catastrophe? It was enough to clean off that hilltop and make everybody in the city take shelter against fallout. Better still, any of the local yokels who happened to be outdoors and looking that way wouldn't be seeing anything else for a couple of hours — meaning me. The dash hadn't dazzled me, nor would it dazzle any of us; our face bowls are heavily leaded, we wear snoopers over our eyes — and we're trained to duck and take it on the armor if we do happen to be looking the wrong way.
+</p>
+
+<p>
+So I merely blinked hard — opened my eyes and stared straight at a local citizen just coming out of an opening in the building ahead of me. He looked at me, I looked at him, and he started to raise something — a weapon, I suppose — as Jelly called out, "Odd numbers! Advance!"
+</p>
+
+<p>
+I didn't have time to fool with him; I was a good five hundred yards short of where I should have been by then. I still had the hand flamer in my left hand; I toasted him and jumped over the building he had been coming out of, as I started to count. A hand flamer is primarily for incendiary work but it is a good defensive anti-personnel weapon in tight quarters; you don't have to aim it much.
+</p>
+
+<p>
+Between excitement and anxiety to catch up I jumped too high and too wide. It's always a temptation to get the most out of your jump gear — but don't do it! It leaves you hanging in the air for seconds, a big fat target. The way to advance is to skim over each building as you come to it, barely clearing it, and taking full advantage of cover while you're down — and never stay in one place more than a second or two, never give them time to target in on you. Be somewhere else, anywhere. Keep moving.
+</p>
+
+<p>
+</p>
+
+<p>This one I goofed — too much for one row of buildings, too little for the row beyond it; I found myself coming down on a roof. But not a nice flat one where I might have tarried three seconds to launch another peewee A-rocket; this roof was a jungle of pipes and stanchions and assorted ironmongery — a factory maybe, or some sort of chemical works. No place to land. Worse still, half a dozen natives were up there. These geezers are humanoid, eight or nine feet tall, much skinnier than we are and with a higher body temperature; they don't wear any clothes and they stand out in a set of snoopers like a neon sign. They look still funnier in daylight with your bare eyes but I would rather fight them than the arachnids — those Bugs make me queezy.
+</p>
+
+<p>
+If these laddies were up there thirty seconds earlier when my rocket hit, then they couldn't see me, or anything. But I couldn't be certain and didn't want to tangle with them in any case; it wasn't that kind of a raid. So I jumped again while I was still in the air, scattering a handful of ten-second fire pills to keep
+them busy, grounded, jumped again at once, and called out, "Second section! Even numbers!...Advance!" and kept right on going to close the gap, while trying to spot, every time I jumped, something worth expending a rocket on. I had three more of the little A-rockets and I certainly didn't intend to take any back with me.
+</p>
+
+<p>
+But I had had pounded into me that you must get your money's worth with atomic weapons — it was only the second time that I had been allowed to carry them. Right now I was trying to spot their waterworks; a direct hit on it could make the whole city uninhabitable, force them to evacuate it without directly killing anyone — just the sort of nuisance we had been sent down to commit. It should — according to the map we had studied under hypnosis — be about three miles upstream from where I was.
+</p>
+
+<p>
+But I couldn't see it; my jumps didn't take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+Fourth and Fifth squads answered, "Wilco"; Ace said, "We're already doin' it — pick up your feet." Red's beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+<p>
+At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I'm no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn't already been told to jump, I guess I wouldn't have got out of there.
+</p>
+
+<p>
+Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+<p>
+There was something on the horizon in the direction of their spaceport — administration & control, maybe, or possibly even a starship. Almost in line and about half as far away was an enormous structure which I couldn't identify even that loosely. The range to the spaceport was extreme but I let the rocket see it, said, "Go find it, baby!" and twisted its tail — slapped the last one in, sent it toward the nearer target, and jumped. That building took a direct hit just as I left it. Either a skinny had judged (correctly) that it was worth one of their buildings to try for one of us, or one of my own mates was getting mighty careless with fireworks. Either way, I didn't want to jump from that spot, even a skimmer; I decided to go through the next couple of buildings instead of over. So I grabbed the heavy flamer off my back as I hit and dipped the snoopers down over my eyes, tackled a wall in front of me with a knife beam at full power. A section of
+wall fell away and I charged in. And backed out even faster. I didn't know what it was I had cracked open. A congregation in church — a skinny flophouse —
+maybe even their defense headquarters. All I knew was that it was a very big room filled with more skinnies than I wanted to see in my whole life.
+</p>
+
+<p>
+Probably not a church, for somebody took a shot at me as I popped back out just a slug that bounced off my armor, made my ears ring, and staggered me without hurting me. But it reminded me that I wasn't supposed to leave without giving them a souvenir of my visit. I grabbed the first thing on my belt and lobbed it in — and heard it start to squawk. As they keep telling you in Basic, doing something constructive at once is better than figuring out the best thing to do hours later. By sheer chance I had done the right thing. This was a special bomb, one each issued to us for this mission with instructions to use them if we found ways to make them effective. The squawking I heard as I threw it was the bomb shouting in skinny talk (free translation): "I'm a thirty-second bomb! I'm a thirty-second bomb! Twenty-nine!... twenty-eight!... twenty-seven! — "It was supposed to frazzle their nerves. Maybe it did; it certainly frazzled mine. Kinder to shoot a man. I didn't wait for the countdown; I jumped, while I wondered whether they would find enough doors and windows to swarm out in time.
+</p>
+
+<p>
+I got a bearing on Red's blinker at the top of the jump and one on Ace as I grounded. I was falling behind again — time to hurry. But three minutes later we had closed the gap; I had Red on my left flank a half mile away. He reported it to Jelly. We heard Jelly's relaxed growl to the entire platoon: "Circle is closed, but the beacon is not down yet. Move forward slowly and mill around, make a little more trouble — but mind the lad on each side of you; don't make trouble for him. Good job, so far — don't spoil it. Platoon! By sections...Muster!"
+</p>
+
+<p>
+It looked like a good job to me, too; much of the city was burning and, although it was almost full light now, it was hard to tell whether bare eyes were better than snoopers, the smoke was so thick. Johnson, our section leader, sounded off: "Second section, call off!" I echoed, "Squads four, five, and six — call off and report!" The assortment of safe circuits we had available in the new model comm units certainly speeded things up; Jelly could talk to anybody or to his section leaders; a section leader could call his whole section, or his non-coms; and the platoon could muster twice as fast, when seconds matter. I listened to the fourth squad call off while I inventoried my remaining firepower and lobbed one bomb toward a skinny who poked his head around a corner. He left and so did I — "Mill around," the boss man had said.
+</p>
+
+<p>
+The fourth squad bumbled the call off until the squad leader remembered to fill in with Jenkins' number; the fifth squad clicked off like an abacus and I began to feel good . . . when the call off stopped after number four in Ace's squad. I called out, "Ace, where's Dizzy?"
+</p>
+
+<p>
+"Shut up," he said. "Number six! Call off!"
+</p>
+
+<p>
+"Six!" Smith answered.
+</p>
+
+<p>
+"Seven!"
+</p>
+
+<p>
+"Sixth squad, Flores missing," Ace completed it. "Squad leader out for pickup."
+</p>
+
+<p>
+"One man absent," I reported to Johnson. "Flores, squad six."
+</p>
+
+<p>
+"Missing or dead?"
+</p>
+
+<p>
+"I don't know. Squad leader and assistant section leader dropping out for pickup."
+</p>
+
+<p>
+"Johnnie, you let Ace take it."
+</p>
+
+<p>
+But I didn't hear him, so I didn't answer. I heard him report to Jelly and I heard Jelly cuss. Now look, I wasn't bucking for a medal — it's the assistant section leader's business to make pickup; he's the chaser, the last man in, expendable. The squad leaders have other work to do. As you've no doubt gathered by now the assistant section leader isn't necessary as long as the section leader is alive. Right that moment I was feeling unusually expendable, almost expended, because I was hearing the sweetest sound in the universe, the beacon the retrieval boat would land on, sounding our recall. The beacon is a robot rocket, fired ahead of the retrieval boat, just a spike that buries itself in the ground and starts broadcasting that welcome, welcome music. The retrieval boat homes in on it automatically three minutes later and you had better be on hand, because the bus can't wait and there won't be another one along.
+</p>
+
+<p>
+But you don't walk away on another cap trooper, not while there's a chance he's still alive — not in Rasczak's Roughnecks. Not in any outfit of the Mobile Infantry. You try to make pickup. I heard Jelly order: "Heads up, lads! Close to retrieval circle and interdict! On the bounce!"
+</p>
+
+<p>
+And I heard the beacon's sweet voice: " — to the everlasting glory of the infantry, shines the name, shines the name of Rodger Young!" and I wanted to head for it so bad I could taste it.
+</p>
+
+<p>
+Instead I was headed the other way, closing on Ace's beacon and expending what I had left of bombs and fire pills and anything else that would weigh me down. "Ace! You got his beacon?"
+</p>
+
+<p>
+"Yes. Go back, Useless!"
+</p>
+
+<p>
+"I've got you by eye now. Where is he?"
+</p>
+
+<p>
+"Right ahead of me, maybe quarter mile. Scram! He's my man ."
+</p>
+
+<p>
+I didn't answer; I simply cut left oblique to reach Ace about where he said Dizzy was.
+</p>
+
+<p>
+And found Ace standing over him, a couple of skinnies flamed down and more running away. I lit beside him. "Let's get him out of his armor — the boat'll be down any second!"
+</p>
+
+<p>
+"He's too bad hurt!"
+</p>
+
+<p>
+I looked and saw that it was true — there was actually a hole in his armor and blood coming out. And I was stumped. To make a wounded pickup you get him out of his armor... then you simply pick him up in your arms — no trouble in a powered suit — and bounce away from there. A bare man weighs less than the ammo and stuff you've expended. "What'll we do?"
+</p>
+
+<p>
+"We carry him," Ace said grimly. "Grab ahold the left side of his belt." He grabbed the right side, we manhandled Flores to his feet. "Lock on! Now... by the numbers, stand by to jump — one — two!"
+</p>
+
+<p>
+We jumped. Not far, not well. One man alone couldn't have gotten him off the ground; an armored suit is too heavy. But split it between two men and it can be done.
+We jumped — and we jumped — and again, and again, with Ace calling it and both of us steadying and catching Dizzy on each grounding. His gyros seemed to be out.
+</p>
+
+<p>
+We heard the beacon cut off as the retrieval boat landed on it — I saw it land . . . and it was too far away. We heard the acting platoon sergeant call out: "In succession, prepare to embark!"
+</p>
+
+<p>
+And Jelly called out, "Belay that order!"
+</p>
+
+<p>
+We broke at last into the open and saw the boat standing on its tail, heard the ululation of its take-off warning — saw the platoon still on the ground around it, in interdiction circle, crouching behind the shield they had formed. Heard Jelly shout, "In succession, man the boat — move!"
+</p>
+
+<p>
+And we were still too far away! I could see them peel off from the first squad, swarm into the boat as the interdiction circle tightened. And a single figure broke out of the circle, came toward us at a speed possible only to a command suit. Jelly caught us while we were in the air, grabbed Flores by his Y-rack and helped us lift. Three jumps got us to the boat. Everybody else was inside but the door was still open. We got him in and closed it while the boat pilot screamed that we had made her miss rendezvous and now we had all bought it! Jelly paid no attention to her; we laid Flores down and lay down beside him. As the blast hit us Jelly was saying to himself, "All present, Lieutenant. Three men hurt — but all present!"
+</p>
+
+<p>
+I'll say this for Captain Deladrier: they don't make any better pilots. A rendezvous, boat to ship in orbit, is precisely calculated. I don't know how, but it is, and you don't change it. You can't.
+</p>
+
+<p>
+Only she did. She saw in her scope that the boat had failed to blast on time; she braked back, picked up speed again — and matched and took us in, just by eye and touch, no time to compute it. If the Almighty ever needs an assistant to keep the stars in their courses, I know where he can look.
+</p>
+
+<p>
+Flores died on the way up.
+</p>
+
+<p>
+ -- repeat --
+</p>
+
+<p>
+Then suddenly nothing. Nothing at all. No sound, no pressure, no weight. Floating in darkness... free fall, maybe thirty miles up, above the effective atmosphere, falling weightlessly toward the surface of a planet you've never seen. But I'm not shaking now; it's the wait beforehand that wears. Once you unload, you can't get hurt — because if anything goes wrong it will happen so fast that you'll buy it without noticing that you're dead, hardly.
+</p>
+
+<p>
+Almost at once I felt the capsule twist and sway, then steady down so that my weight was on my back...weight that built up quickly until I was at my full weight (0.87 gee, we had been told) for that planet as the capsule reached terminal velocity for the thin upper atmosphere. A pilot who is a real artist (and the Captain was) will approach and brake so that your launching speed as you shoot out of the tube places you just dead in space relative to the rotational speed of the planet at that latitude. The loaded capsules are heavy; they punch through the high, thin winds of the upper atmosphere without being blown too far out of position — but just the same a platoon is bound to disperse on the way down, lose some of the perfect formation in which it unloads. A sloppy pilot can make this still worse, scatter a strike group over so much terrain that it can't make rendezvous for retrieval, much less carry out its mission. An infantryman can fight only if somebody else delivers him to his zone; in a way I suppose pilots are just as essential as we are.
+</p>
+
+<p>
+I could tell from the gentle way my capsule entered the atmosphere that the Captain had laid us down with as near zero lateral vector as you could ask for. I felt happy — not only a tight formation when we hit and no time wasted, but also a pilot who puts you down properly is a pilot who is smart and precise on retrieval.
+</p>
+
+<p>
+The outer shell burned away and sloughed off — unevenly, for I tumbled. Then the rest of it went and I straightened out. The turbulence brakes of the second shell bit in and the ride got rough... and still rougher as they burned off one at a time and the second shell began to go to pieces. One of the things that helps a capsule trooper to live long enough to draw a pension is that the skins peeling off his capsule not only slow him down, they also fill the sky over the target area with so much junk that radar picks up reflections from dozens of targets for each man in the drop, any one of which could be a man, or a bomb, or anything. It's enough to give a ballistic computer nervous breakdowns — and does. To add to the fun your ship lays a series of dummy eggs in the seconds immediately following your drop, dummies that will fall faster because they don't slough. They get under you, explode, throw out "window," even operate as transponders, rocket sideways, and do other things to add to the confusion of your reception committee on the ground.
+</p>
+
+<p>
+In the meantime your ship is locked firmly on the directional beacon of your platoon leader, ignoring the radar "noise" it has created and following you in, computing your impact for future use. When the second shell was gone, the third shell automatically opened my first ribbon chute. It didn't last long but it wasn't expected to; one good, hard jerk at several gee and it went its way and I went mine. The second chute lasted a little bit longer and the third chute lasted quite a while; it began to be rather too warm inside the capsule and I started thinking about landing.
+</p>
+
+<p>
+The third shell peeled off when its last chute was gone and now I had nothing around me but my suit armor and a plastic egg. I was still strapped inside it, unable to move; it was time to decide how and where I was going to ground. Without moving my arms (I couldn't) I thumbed the switch for a proximity reading and read it when it flashed on in the instrument reflector inside my helmet in front of my forehead. A mile and eight-tenths — A little closer than I liked, especially without company. The inner egg had reached steady speed, no more help to be gained by staying inside it, and its skin temperature indicated that it would not open automatically for a while yet — so I flipped a switch with my other thumb and got rid of it.
+</p>
+
+<p>
+The first charge cut all the straps; the second charge exploded the plastic egg away from me in eight separate pieces — and I was outdoors, sitting on air, and could see! Better still, the eight discarded pieces were metal-coated (except for the small bit I had taken proximity reading through) and would give back the same reflection as an armored man. Any radar viewer, alive or cybernetic, would now have a sad time sorting me out from the junk nearest me, not to mention the thousands of other bits and pieces for miles on each side, above, and below me. Part of a mobile infantryman's training is to let him see, from the ground and both by eye and by radar, just how confusing a drop is to the forces on the ground — because you feel awful naked up there. It is easy to panic and either open a chute too soon and become a sitting duck (do ducks really sit? — if so, why?) or fail to open it and break your ankles, likewise backbone and skull. So I stretched, getting the kinks out, and looked around... then doubled up again and straightened out in a swan dive face down and took a good look. It was night down there, as planned, but infrared snoopers let you size up terrain quite well after you are used to them. The river that cut diagonally through the city was almost below me and coming up fast, shining out clearly with a higher temperature than the land. I didn't care which side of it I landed on but I didn't want to land in it; it would slow me down.
+</p>
+
+<p>
+I noticed a dash off to the right at about my altitude; some unfriendly native down below had burned what was probably a piece of my egg. So I fired my first chute at once, intending if possible to jerk myself right off his screen as he followed the targets down in closing range. I braced for the shock, rode it, then floated down for about twenty seconds before unloading the chute — not wishing to call attention to myself in still another way by not falling at the speed of the other stuff around me. It must have worked; I wasn't burned.
+</p>
+
+<p>
+About six hundred feet up I shot the second chute... saw very quickly that I was being carried over into the river, found that I was going to pass about a hundred feet up over a flat-roofed warehouse or some such by the river... blew the chute free and came in for a good enough if rather bouncy landing on the roof by means of the suit's jump jets. I was scanning for Sergeant Jelal's beacon as I hit. And found that I was on the wrong side of the river; Jelly's star showed up on the compass ring inside my helmet far south of where it should have been — I was too far north. I trotted toward the river side of the roof as I took a range and bearing on the squad leader next to me, found that he was over a mile out of position, called, "Ace! dress your line," tossed a bomb behind me as I stepped off the building and across the river. Ace answered as I could have expected — Ace should have had my spot but he didn't want to give up his squad; nevertheless he didn't fancy taking orders from me.
+</p>
+
+<p>
+The warehouse went up behind me and the blast hit me while I was still over the river, instead of being shielded by the buildings on the far side as I should have been. It darn near tumbled my gyros and I came close to tumbling myself. I had set that bomb for fifteen seconds... or had I? I suddenly realized that I had let myself get excited, the worst thing you can do once you're on the ground. "Just like a drill," that was the way, just as Jelly had warned me. Take your time and do it right, even if it takes another half second. As I hit I took another reading on Ace and told him again to realign his squad. He didn't answer but he was already doing it. I let it ride. As long as Ace did his job, I could afford to swallow his surliness — for now. But back aboard ship (if Jelly kept me on as assistant section leader) we would eventually have to pick a quiet spot and find out who was boss. He was a career corporal and I was just a term lance acting as corporal, but he was under me and you can't afford to take any lip under those circumstances. Not permanently.
+</p>
+
+<p>
+But I didn't have time then to think about it; while I was jumping the river I had spotted a juicy target and I wanted to get it before somebody else noticed it — a lovely big group of what looked like public buildings on a hill. Temples, maybe... or a palace. They were miles outside the area we were sweeping, but one rule of a smash & run is to expend at least half your ammo outside your sweep area; that way the enemy is kept confused as to where you actually are — that and keep moving, do everything fast. You're always heavily outnumbered; surprise and speed are what saves you. I was already loading my rocket launcher while I was checking on Ace and telling him for the second time to straighten up. Jelly's voice reached me right on top of that on the all-hands circuit: "Platoon! By leapfrog! Forward!" My boss, Sergeant Johnson, echoed, "By leapfrog! Odd numbers! Advance!" That left me with nothing to worry about for twenty seconds, so I jumped up on the building nearest me, raised the launcher to my shoulder, found the target and pulled the first trigger to let the rocket have a look at its target — pulled the second trigger and kissed it on its way, jumped back to the ground. "Second section, even numbers!" I called out... waited for the count in my mind and ordered, "Advance!"
+</p>
+
+<p>
+And did so myself, hopping over the next row of buildings, and, while I was in the air, fanning the first row by the river front with a hand flamer. They seemed to be wood construction and it looked like time to start a good fire — with luck, some of those warehouses would house oil products, or even explosives. As I hit, the Y-rack on my shoulders launched two small H. E. bombs a couple of hundred yards each way to my right and left flanks but I never saw what they did as just then my first rocket hit — that unmistakable (if you've ever seen one) brilliance of an atomic explosion. It was just a peewee, of course, less than two kilotons nominal yield, with tamper and implosion squeeze to produce results from a less-than-critical mass — but then who wants to be bunk mates with a cosmic catastrophe? It was enough to clean off that hilltop and make everybody in the city take shelter against fallout. Better still, any of the local yokels who happened to be outdoors and looking that way wouldn't be seeing anything else for a couple of hours — meaning me. The dash hadn't dazzled me, nor would it dazzle any of us; our face bowls are heavily leaded, we wear snoopers over our eyes — and we're trained to duck and take it on the armor if we do happen to be looking the wrong way.
+</p>
+
+<p>
+So I merely blinked hard — opened my eyes and stared straight at a local citizen just coming out of an opening in the building ahead of me. He looked at me, I looked at him, and he started to raise something — a weapon, I suppose — as Jelly called out, "Odd numbers! Advance!"
+</p>
+
+<p>
+I didn't have time to fool with him; I was a good five hundred yards short of where I should have been by then. I still had the hand flamer in my left hand; I toasted him and jumped over the building he had been coming out of, as I started to count. A hand flamer is primarily for incendiary work but it is a good defensive anti-personnel weapon in tight quarters; you don't have to aim it much.
+</p>
+
+<p>
+Between excitement and anxiety to catch up I jumped too high and too wide. It's always a temptation to get the most out of your jump gear — but don't do it! It leaves you hanging in the air for seconds, a big fat target. The way to advance is to skim over each building as you come to it, barely clearing it, and taking full advantage of cover while you're down — and never stay in one place more than a second or two, never give them time to target in on you. Be somewhere else, anywhere. Keep moving.
+</p>
+
+<p>
+</p>
+
+<p>This one I goofed — too much for one row of buildings, too little for the row beyond it; I found myself coming down on a roof. But not a nice flat one where I might have tarried three seconds to launch another peewee A-rocket; this roof was a jungle of pipes and stanchions and assorted ironmongery — a factory maybe, or some sort of chemical works. No place to land. Worse still, half a dozen natives were up there. These geezers are humanoid, eight or nine feet tall, much skinnier than we are and with a higher body temperature; they don't wear any clothes and they stand out in a set of snoopers like a neon sign. They look still funnier in daylight with your bare eyes but I would rather fight them than the arachnids — those Bugs make me queezy.
+</p>
+
+<p>
+If these laddies were up there thirty seconds earlier when my rocket hit, then they couldn't see me, or anything. But I couldn't be certain and didn't want to tangle with them in any case; it wasn't that kind of a raid. So I jumped again while I was still in the air, scattering a handful of ten-second fire pills to keep
+them busy, grounded, jumped again at once, and called out, "Second section! Even numbers!...Advance!" and kept right on going to close the gap, while trying to spot, every time I jumped, something worth expending a rocket on. I had three more of the little A-rockets and I certainly didn't intend to take any back with me.
+</p>
+
+<p>
+But I had had pounded into me that you must get your money's worth with atomic weapons — it was only the second time that I had been allowed to carry them. Right now I was trying to spot their waterworks; a direct hit on it could make the whole city uninhabitable, force them to evacuate it without directly killing anyone — just the sort of nuisance we had been sent down to commit. It should — according to the map we had studied under hypnosis — be about three miles upstream from where I was.
+</p>
+
+<p>
+But I couldn't see it; my jumps didn't take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+Fourth and Fifth squads answered, "Wilco"; Ace said, "We're already doin' it — pick up your feet." Red's beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+<p>
+At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I'm no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn't already been told to jump, I guess I wouldn't have got out of there.
+</p>
+
+<p>
+Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+<p>
+There was something on the horizon in the direction of their spaceport — administration & control, maybe, or possibly even a starship. Almost in line and about half as far away was an enormous structure which I couldn't identify even that loosely. The range to the spaceport was extreme but I let the rocket see it, said, "Go find it, baby!" and twisted its tail — slapped the last one in, sent it toward the nearer target, and jumped. That building took a direct hit just as I left it. Either a skinny had judged (correctly) that it was worth one of their buildings to try for one of us, or one of my own mates was getting mighty careless with fireworks. Either way, I didn't want to jump from that spot, even a skimmer; I decided to go through the next couple of buildings instead of over. So I grabbed the heavy flamer off my back as I hit and dipped the snoopers down over my eyes, tackled a wall in front of me with a knife beam at full power. A section of
+wall fell away and I charged in. And backed out even faster. I didn't know what it was I had cracked open. A congregation in church — a skinny flophouse —
+maybe even their defense headquarters. All I knew was that it was a very big room filled with more skinnies than I wanted to see in my whole life.
+</p>
+
+<p>
+Probably not a church, for somebody took a shot at me as I popped back out just a slug that bounced off my armor, made my ears ring, and staggered me without hurting me. But it reminded me that I wasn't supposed to leave without giving them a souvenir of my visit. I grabbed the first thing on my belt and lobbed it in — and heard it start to squawk. As they keep telling you in Basic, doing something constructive at once is better than figuring out the best thing to do hours later. By sheer chance I had done the right thing. This was a special bomb, one each issued to us for this mission with instructions to use them if we found ways to make them effective. The squawking I heard as I threw it was the bomb shouting in skinny talk (free translation): "I'm a thirty-second bomb! I'm a thirty-second bomb! Twenty-nine!... twenty-eight!... twenty-seven! — "It was supposed to frazzle their nerves. Maybe it did; it certainly frazzled mine. Kinder to shoot a man. I didn't wait for the countdown; I jumped, while I wondered whether they would find enough doors and windows to swarm out in time.
+</p>
+
+<p>
+I got a bearing on Red's blinker at the top of the jump and one on Ace as I grounded. I was falling behind again — time to hurry. But three minutes later we had closed the gap; I had Red on my left flank a half mile away. He reported it to Jelly. We heard Jelly's relaxed growl to the entire platoon: "Circle is closed, but the beacon is not down yet. Move forward slowly and mill around, make a little more trouble — but mind the lad on each side of you; don't make trouble for him. Good job, so far — don't spoil it. Platoon! By sections...Muster!"
+</p>
+
+<p>
+It looked like a good job to me, too; much of the city was burning and, although it was almost full light now, it was hard to tell whether bare eyes were better than snoopers, the smoke was so thick. Johnson, our section leader, sounded off: "Second section, call off!" I echoed, "Squads four, five, and six — call off and report!" The assortment of safe circuits we had available in the new model comm units certainly speeded things up; Jelly could talk to anybody or to his section leaders; a section leader could call his whole section, or his non-coms; and the platoon could muster twice as fast, when seconds matter. I listened to the fourth squad call off while I inventoried my remaining firepower and lobbed one bomb toward a skinny who poked his head around a corner. He left and so did I — "Mill around," the boss man had said.
+</p>
+
+<p>
+The fourth squad bumbled the call off until the squad leader remembered to fill in with Jenkins' number; the fifth squad clicked off like an abacus and I began to feel good . . . when the call off stopped after number four in Ace's squad. I called out, "Ace, where's Dizzy?"
+</p>
+
+<p>
+"Shut up," he said. "Number six! Call off!"
+</p>
+
+<p>
+"Six!" Smith answered.
+</p>
+
+<p>
+"Seven!"
+</p>
+
+<p>
+"Sixth squad, Flores missing," Ace completed it. "Squad leader out for pickup."
+</p>
+
+<p>
+"One man absent," I reported to Johnson. "Flores, squad six."
+</p>
+
+<p>
+"Missing or dead?"
+</p>
+
+<p>
+"I don't know. Squad leader and assistant section leader dropping out for pickup."
+</p>
+
+<p>
+"Johnnie, you let Ace take it."
+</p>
+
+<p>
+But I didn't hear him, so I didn't answer. I heard him report to Jelly and I heard Jelly cuss. Now look, I wasn't bucking for a medal — it's the assistant section leader's business to make pickup; he's the chaser, the last man in, expendable. The squad leaders have other work to do. As you've no doubt gathered by now the assistant section leader isn't necessary as long as the section leader is alive. Right that moment I was feeling unusually expendable, almost expended, because I was hearing the sweetest sound in the universe, the beacon the retrieval boat would land on, sounding our recall. The beacon is a robot rocket, fired ahead of the retrieval boat, just a spike that buries itself in the ground and starts broadcasting that welcome, welcome music. The retrieval boat homes in on it automatically three minutes later and you had better be on hand, because the bus can't wait and there won't be another one along.
+</p>
+
+<p>
+But you don't walk away on another cap trooper, not while there's a chance he's still alive — not in Rasczak's Roughnecks. Not in any outfit of the Mobile Infantry. You try to make pickup. I heard Jelly order: "Heads up, lads! Close to retrieval circle and interdict! On the bounce!"
+</p>
+
+<p>
+And I heard the beacon's sweet voice: " — to the everlasting glory of the infantry, shines the name, shines the name of Rodger Young!" and I wanted to head for it so bad I could taste it.
+</p>
+
+<p>
+Instead I was headed the other way, closing on Ace's beacon and expending what I had left of bombs and fire pills and anything else that would weigh me down. "Ace! You got his beacon?"
+</p>
+
+<p>
+"Yes. Go back, Useless!"
+</p>
+
+<p>
+"I've got you by eye now. Where is he?"
+</p>
+
+<p>
+"Right ahead of me, maybe quarter mile. Scram! He's my man ."
+</p>
+
+<p>
+I didn't answer; I simply cut left oblique to reach Ace about where he said Dizzy was.
+</p>
+
+<p>
+And found Ace standing over him, a couple of skinnies flamed down and more running away. I lit beside him. "Let's get him out of his armor — the boat'll be down any second!"
+</p>
+
+<p>
+"He's too bad hurt!"
+</p>
+
+<p>
+I looked and saw that it was true — there was actually a hole in his armor and blood coming out. And I was stumped. To make a wounded pickup you get him out of his armor... then you simply pick him up in your arms — no trouble in a powered suit — and bounce away from there. A bare man weighs less than the ammo and stuff you've expended. "What'll we do?"
+</p>
+
+<p>
+"We carry him," Ace said grimly. "Grab ahold the left side of his belt." He grabbed the right side, we manhandled Flores to his feet. "Lock on! Now... by the numbers, stand by to jump — one — two!"
+</p>
+
+<p>
+We jumped. Not far, not well. One man alone couldn't have gotten him off the ground; an armored suit is too heavy. But split it between two men and it can be done.
+We jumped — and we jumped — and again, and again, with Ace calling it and both of us steadying and catching Dizzy on each grounding. His gyros seemed to be out.
+</p>
+
+<p>
+We heard the beacon cut off as the retrieval boat landed on it — I saw it land . . . and it was too far away. We heard the acting platoon sergeant call out: "In succession, prepare to embark!"
+</p>
+
+<p>
+And Jelly called out, "Belay that order!"
+</p>
+
+<p>
+We broke at last into the open and saw the boat standing on its tail, heard the ululation of its take-off warning — saw the platoon still on the ground around it, in interdiction circle, crouching behind the shield they had formed. Heard Jelly shout, "In succession, man the boat — move!"
+</p>
+
+<p>
+And we were still too far away! I could see them peel off from the first squad, swarm into the boat as the interdiction circle tightened. And a single figure broke out of the circle, came toward us at a speed possible only to a command suit. Jelly caught us while we were in the air, grabbed Flores by his Y-rack and helped us lift. Three jumps got us to the boat. Everybody else was inside but the door was still open. We got him in and closed it while the boat pilot screamed that we had made her miss rendezvous and now we had all bought it! Jelly paid no attention to her; we laid Flores down and lay down beside him. As the blast hit us Jelly was saying to himself, "All present, Lieutenant. Three men hurt — but all present!"
+</p>
+
+<p>
+I'll say this for Captain Deladrier: they don't make any better pilots. A rendezvous, boat to ship in orbit, is precisely calculated. I don't know how, but it is, and you don't change it. You can't.
+</p>
+
+<p>
+Only she did. She saw in her scope that the boat had failed to blast on time; she braked back, picked up speed again — and matched and took us in, just by eye and touch, no time to compute it. If the Almighty ever needs an assistant to keep the stars in their courses, I know where he can look.
+</p>
+
+<p>
+Flores died on the way up.
+</p>
+
+<p>
+ -- repeat --
+</p>
+
+<p>
+Then suddenly nothing. Nothing at all. No sound, no pressure, no weight. Floating in darkness... free fall, maybe thirty miles up, above the effective atmosphere, falling weightlessly toward the surface of a planet you've never seen. But I'm not shaking now; it's the wait beforehand that wears. Once you unload, you can't get hurt — because if anything goes wrong it will happen so fast that you'll buy it without noticing that you're dead, hardly.
+</p>
+
+<p>
+Almost at once I felt the capsule twist and sway, then steady down so that my weight was on my back...weight that built up quickly until I was at my full weight (0.87 gee, we had been told) for that planet as the capsule reached terminal velocity for the thin upper atmosphere. A pilot who is a real artist (and the Captain was) will approach and brake so that your launching speed as you shoot out of the tube places you just dead in space relative to the rotational speed of the planet at that latitude. The loaded capsules are heavy; they punch through the high, thin winds of the upper atmosphere without being blown too far out of position — but just the same a platoon is bound to disperse on the way down, lose some of the perfect formation in which it unloads. A sloppy pilot can make this still worse, scatter a strike group over so much terrain that it can't make rendezvous for retrieval, much less carry out its mission. An infantryman can fight only if somebody else delivers him to his zone; in a way I suppose pilots are just as essential as we are.
+</p>
+
+<p>
+I could tell from the gentle way my capsule entered the atmosphere that the Captain had laid us down with as near zero lateral vector as you could ask for. I felt happy — not only a tight formation when we hit and no time wasted, but also a pilot who puts you down properly is a pilot who is smart and precise on retrieval.
+</p>
+
+<p>
+The outer shell burned away and sloughed off — unevenly, for I tumbled. Then the rest of it went and I straightened out. The turbulence brakes of the second shell bit in and the ride got rough... and still rougher as they burned off one at a time and the second shell began to go to pieces. One of the things that helps a capsule trooper to live long enough to draw a pension is that the skins peeling off his capsule not only slow him down, they also fill the sky over the target area with so much junk that radar picks up reflections from dozens of targets for each man in the drop, any one of which could be a man, or a bomb, or anything. It's enough to give a ballistic computer nervous breakdowns — and does. To add to the fun your ship lays a series of dummy eggs in the seconds immediately following your drop, dummies that will fall faster because they don't slough. They get under you, explode, throw out "window," even operate as transponders, rocket sideways, and do other things to add to the confusion of your reception committee on the ground.
+</p>
+
+<p>
+In the meantime your ship is locked firmly on the directional beacon of your platoon leader, ignoring the radar "noise" it has created and following you in, computing your impact for future use. When the second shell was gone, the third shell automatically opened my first ribbon chute. It didn't last long but it wasn't expected to; one good, hard jerk at several gee and it went its way and I went mine. The second chute lasted a little bit longer and the third chute lasted quite a while; it began to be rather too warm inside the capsule and I started thinking about landing.
+</p>
+
+<p>
+The third shell peeled off when its last chute was gone and now I had nothing around me but my suit armor and a plastic egg. I was still strapped inside it, unable to move; it was time to decide how and where I was going to ground. Without moving my arms (I couldn't) I thumbed the switch for a proximity reading and read it when it flashed on in the instrument reflector inside my helmet in front of my forehead. A mile and eight-tenths — A little closer than I liked, especially without company. The inner egg had reached steady speed, no more help to be gained by staying inside it, and its skin temperature indicated that it would not open automatically for a while yet — so I flipped a switch with my other thumb and got rid of it.
+</p>
+
+<p>
+The first charge cut all the straps; the second charge exploded the plastic egg away from me in eight separate pieces — and I was outdoors, sitting on air, and could see! Better still, the eight discarded pieces were metal-coated (except for the small bit I had taken proximity reading through) and would give back the same reflection as an armored man. Any radar viewer, alive or cybernetic, would now have a sad time sorting me out from the junk nearest me, not to mention the thousands of other bits and pieces for miles on each side, above, and below me. Part of a mobile infantryman's training is to let him see, from the ground and both by eye and by radar, just how confusing a drop is to the forces on the ground — because you feel awful naked up there. It is easy to panic and either open a chute too soon and become a sitting duck (do ducks really sit? — if so, why?) or fail to open it and break your ankles, likewise backbone and skull. So I stretched, getting the kinks out, and looked around... then doubled up again and straightened out in a swan dive face down and took a good look. It was night down there, as planned, but infrared snoopers let you size up terrain quite well after you are used to them. The river that cut diagonally through the city was almost below me and coming up fast, shining out clearly with a higher temperature than the land. I didn't care which side of it I landed on but I didn't want to land in it; it would slow me down.
+</p>
+
+<p>
+I noticed a dash off to the right at about my altitude; some unfriendly native down below had burned what was probably a piece of my egg. So I fired my first chute at once, intending if possible to jerk myself right off his screen as he followed the targets down in closing range. I braced for the shock, rode it, then floated down for about twenty seconds before unloading the chute — not wishing to call attention to myself in still another way by not falling at the speed of the other stuff around me. It must have worked; I wasn't burned.
+</p>
+
+<p>
+About six hundred feet up I shot the second chute... saw very quickly that I was being carried over into the river, found that I was going to pass about a hundred feet up over a flat-roofed warehouse or some such by the river... blew the chute free and came in for a good enough if rather bouncy landing on the roof by means of the suit's jump jets. I was scanning for Sergeant Jelal's beacon as I hit. And found that I was on the wrong side of the river; Jelly's star showed up on the compass ring inside my helmet far south of where it should have been — I was too far north. I trotted toward the river side of the roof as I took a range and bearing on the squad leader next to me, found that he was over a mile out of position, called, "Ace! dress your line," tossed a bomb behind me as I stepped off the building and across the river. Ace answered as I could have expected — Ace should have had my spot but he didn't want to give up his squad; nevertheless he didn't fancy taking orders from me.
+</p>
+
+<p>
+The warehouse went up behind me and the blast hit me while I was still over the river, instead of being shielded by the buildings on the far side as I should have been. It darn near tumbled my gyros and I came close to tumbling myself. I had set that bomb for fifteen seconds... or had I? I suddenly realized that I had let myself get excited, the worst thing you can do once you're on the ground. "Just like a drill," that was the way, just as Jelly had warned me. Take your time and do it right, even if it takes another half second. As I hit I took another reading on Ace and told him again to realign his squad. He didn't answer but he was already doing it. I let it ride. As long as Ace did his job, I could afford to swallow his surliness — for now. But back aboard ship (if Jelly kept me on as assistant section leader) we would eventually have to pick a quiet spot and find out who was boss. He was a career corporal and I was just a term lance acting as corporal, but he was under me and you can't afford to take any lip under those circumstances. Not permanently.
+</p>
+
+<p>
+But I didn't have time then to think about it; while I was jumping the river I had spotted a juicy target and I wanted to get it before somebody else noticed it — a lovely big group of what looked like public buildings on a hill. Temples, maybe... or a palace. They were miles outside the area we were sweeping, but one rule of a smash & run is to expend at least half your ammo outside your sweep area; that way the enemy is kept confused as to where you actually are — that and keep moving, do everything fast. You're always heavily outnumbered; surprise and speed are what saves you. I was already loading my rocket launcher while I was checking on Ace and telling him for the second time to straighten up. Jelly's voice reached me right on top of that on the all-hands circuit: "Platoon! By leapfrog! Forward!" My boss, Sergeant Johnson, echoed, "By leapfrog! Odd numbers! Advance!" That left me with nothing to worry about for twenty seconds, so I jumped up on the building nearest me, raised the launcher to my shoulder, found the target and pulled the first trigger to let the rocket have a look at its target — pulled the second trigger and kissed it on its way, jumped back to the ground. "Second section, even numbers!" I called out... waited for the count in my mind and ordered, "Advance!"
+</p>
+
+<p>
+And did so myself, hopping over the next row of buildings, and, while I was in the air, fanning the first row by the river front with a hand flamer. They seemed to be wood construction and it looked like time to start a good fire — with luck, some of those warehouses would house oil products, or even explosives. As I hit, the Y-rack on my shoulders launched two small H. E. bombs a couple of hundred yards each way to my right and left flanks but I never saw what they did as just then my first rocket hit — that unmistakable (if you've ever seen one) brilliance of an atomic explosion. It was just a peewee, of course, less than two kilotons nominal yield, with tamper and implosion squeeze to produce results from a less-than-critical mass — but then who wants to be bunk mates with a cosmic catastrophe? It was enough to clean off that hilltop and make everybody in the city take shelter against fallout. Better still, any of the local yokels who happened to be outdoors and looking that way wouldn't be seeing anything else for a couple of hours — meaning me. The dash hadn't dazzled me, nor would it dazzle any of us; our face bowls are heavily leaded, we wear snoopers over our eyes — and we're trained to duck and take it on the armor if we do happen to be looking the wrong way.
+</p>
+
+<p>
+So I merely blinked hard — opened my eyes and stared straight at a local citizen just coming out of an opening in the building ahead of me. He looked at me, I looked at him, and he started to raise something — a weapon, I suppose — as Jelly called out, "Odd numbers! Advance!"
+</p>
+
+<p>
+I didn't have time to fool with him; I was a good five hundred yards short of where I should have been by then. I still had the hand flamer in my left hand; I toasted him and jumped over the building he had been coming out of, as I started to count. A hand flamer is primarily for incendiary work but it is a good defensive anti-personnel weapon in tight quarters; you don't have to aim it much.
+</p>
+
+<p>
+Between excitement and anxiety to catch up I jumped too high and too wide. It's always a temptation to get the most out of your jump gear — but don't do it! It leaves you hanging in the air for seconds, a big fat target. The way to advance is to skim over each building as you come to it, barely clearing it, and taking full advantage of cover while you're down — and never stay in one place more than a second or two, never give them time to target in on you. Be somewhere else, anywhere. Keep moving.
+</p>
+
+<p>
+</p>
+
+<p>This one I goofed — too much for one row of buildings, too little for the row beyond it; I found myself coming down on a roof. But not a nice flat one where I might have tarried three seconds to launch another peewee A-rocket; this roof was a jungle of pipes and stanchions and assorted ironmongery — a factory maybe, or some sort of chemical works. No place to land. Worse still, half a dozen natives were up there. These geezers are humanoid, eight or nine feet tall, much skinnier than we are and with a higher body temperature; they don't wear any clothes and they stand out in a set of snoopers like a neon sign. They look still funnier in daylight with your bare eyes but I would rather fight them than the arachnids — those Bugs make me queezy.
+</p>
+
+<p>
+If these laddies were up there thirty seconds earlier when my rocket hit, then they couldn't see me, or anything. But I couldn't be certain and didn't want to tangle with them in any case; it wasn't that kind of a raid. So I jumped again while I was still in the air, scattering a handful of ten-second fire pills to keep
+them busy, grounded, jumped again at once, and called out, "Second section! Even numbers!...Advance!" and kept right on going to close the gap, while trying to spot, every time I jumped, something worth expending a rocket on. I had three more of the little A-rockets and I certainly didn't intend to take any back with me.
+</p>
+
+<p>
+But I had had pounded into me that you must get your money's worth with atomic weapons — it was only the second time that I had been allowed to carry them. Right now I was trying to spot their waterworks; a direct hit on it could make the whole city uninhabitable, force them to evacuate it without directly killing anyone — just the sort of nuisance we had been sent down to commit. It should — according to the map we had studied under hypnosis — be about three miles upstream from where I was.
+</p>
+
+<p>
+But I couldn't see it; my jumps didn't take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+Fourth and Fifth squads answered, "Wilco"; Ace said, "We're already doin' it — pick up your feet." Red's beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+<p>
+At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I'm no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn't already been told to jump, I guess I wouldn't have got out of there.
+</p>
+
+<p>
+Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+<p>
+There was something on the horizon in the direction of their spaceport — administration & control, maybe, or possibly even a starship. Almost in line and about half as far away was an enormous structure which I couldn't identify even that loosely. The range to the spaceport was extreme but I let the rocket see it, said, "Go find it, baby!" and twisted its tail — slapped the last one in, sent it toward the nearer target, and jumped. That building took a direct hit just as I left it. Either a skinny had judged (correctly) that it was worth one of their buildings to try for one of us, or one of my own mates was getting mighty careless with fireworks. Either way, I didn't want to jump from that spot, even a skimmer; I decided to go through the next couple of buildings instead of over. So I grabbed the heavy flamer off my back as I hit and dipped the snoopers down over my eyes, tackled a wall in front of me with a knife beam at full power. A section of
+wall fell away and I charged in. And backed out even faster. I didn't know what it was I had cracked open. A congregation in church — a skinny flophouse —
+maybe even their defense headquarters. All I knew was that it was a very big room filled with more skinnies than I wanted to see in my whole life.
+</p>
+
+<p>
+Probably not a church, for somebody took a shot at me as I popped back out just a slug that bounced off my armor, made my ears ring, and staggered me without hurting me. But it reminded me that I wasn't supposed to leave without giving them a souvenir of my visit. I grabbed the first thing on my belt and lobbed it in — and heard it start to squawk. As they keep telling you in Basic, doing something constructive at once is better than figuring out the best thing to do hours later. By sheer chance I had done the right thing. This was a special bomb, one each issued to us for this mission with instructions to use them if we found ways to make them effective. The squawking I heard as I threw it was the bomb shouting in skinny talk (free translation): "I'm a thirty-second bomb! I'm a thirty-second bomb! Twenty-nine!... twenty-eight!... twenty-seven! — "It was supposed to frazzle their nerves. Maybe it did; it certainly frazzled mine. Kinder to shoot a man. I didn't wait for the countdown; I jumped, while I wondered whether they would find enough doors and windows to swarm out in time.
+</p>
+
+<p>
+I got a bearing on Red's blinker at the top of the jump and one on Ace as I grounded. I was falling behind again — time to hurry. But three minutes later we had closed the gap; I had Red on my left flank a half mile away. He reported it to Jelly. We heard Jelly's relaxed growl to the entire platoon: "Circle is closed, but the beacon is not down yet. Move forward slowly and mill around, make a little more trouble — but mind the lad on each side of you; don't make trouble for him. Good job, so far — don't spoil it. Platoon! By sections...Muster!"
+</p>
+
+<p>
+It looked like a good job to me, too; much of the city was burning and, although it was almost full light now, it was hard to tell whether bare eyes were better than snoopers, the smoke was so thick. Johnson, our section leader, sounded off: "Second section, call off!" I echoed, "Squads four, five, and six — call off and report!" The assortment of safe circuits we had available in the new model comm units certainly speeded things up; Jelly could talk to anybody or to his section leaders; a section leader could call his whole section, or his non-coms; and the platoon could muster twice as fast, when seconds matter. I listened to the fourth squad call off while I inventoried my remaining firepower and lobbed one bomb toward a skinny who poked his head around a corner. He left and so did I — "Mill around," the boss man had said.
+</p>
+
+<p>
+The fourth squad bumbled the call off until the squad leader remembered to fill in with Jenkins' number; the fifth squad clicked off like an abacus and I began to feel good . . . when the call off stopped after number four in Ace's squad. I called out, "Ace, where's Dizzy?"
+</p>
+
+<p>
+"Shut up," he said. "Number six! Call off!"
+</p>
+
+<p>
+"Six!" Smith answered.
+</p>
+
+<p>
+"Seven!"
+</p>
+
+<p>
+"Sixth squad, Flores missing," Ace completed it. "Squad leader out for pickup."
+</p>
+
+<p>
+"One man absent," I reported to Johnson. "Flores, squad six."
+</p>
+
+<p>
+"Missing or dead?"
+</p>
+
+<p>
+"I don't know. Squad leader and assistant section leader dropping out for pickup."
+</p>
+
+<p>
+"Johnnie, you let Ace take it."
+</p>
+
+<p>
+But I didn't hear him, so I didn't answer. I heard him report to Jelly and I heard Jelly cuss. Now look, I wasn't bucking for a medal — it's the assistant section leader's business to make pickup; he's the chaser, the last man in, expendable. The squad leaders have other work to do. As you've no doubt gathered by now the assistant section leader isn't necessary as long as the section leader is alive. Right that moment I was feeling unusually expendable, almost expended, because I was hearing the sweetest sound in the universe, the beacon the retrieval boat would land on, sounding our recall. The beacon is a robot rocket, fired ahead of the retrieval boat, just a spike that buries itself in the ground and starts broadcasting that welcome, welcome music. The retrieval boat homes in on it automatically three minutes later and you had better be on hand, because the bus can't wait and there won't be another one along.
+</p>
+
+<p>
+But you don't walk away on another cap trooper, not while there's a chance he's still alive — not in Rasczak's Roughnecks. Not in any outfit of the Mobile Infantry. You try to make pickup. I heard Jelly order: "Heads up, lads! Close to retrieval circle and interdict! On the bounce!"
+</p>
+
+<p>
+And I heard the beacon's sweet voice: " — to the everlasting glory of the infantry, shines the name, shines the name of Rodger Young!" and I wanted to head for it so bad I could taste it.
+</p>
+
+<p>
+Instead I was headed the other way, closing on Ace's beacon and expending what I had left of bombs and fire pills and anything else that would weigh me down. "Ace! You got his beacon?"
+</p>
+
+<p>
+"Yes. Go back, Useless!"
+</p>
+
+<p>
+"I've got you by eye now. Where is he?"
+</p>
+
+<p>
+"Right ahead of me, maybe quarter mile. Scram! He's my man ."
+</p>
+
+<p>
+I didn't answer; I simply cut left oblique to reach Ace about where he said Dizzy was.
+</p>
+
+<p>
+And found Ace standing over him, a couple of skinnies flamed down and more running away. I lit beside him. "Let's get him out of his armor — the boat'll be down any second!"
+</p>
+
+<p>
+"He's too bad hurt!"
+</p>
+
+<p>
+I looked and saw that it was true — there was actually a hole in his armor and blood coming out. And I was stumped. To make a wounded pickup you get him out of his armor... then you simply pick him up in your arms — no trouble in a powered suit — and bounce away from there. A bare man weighs less than the ammo and stuff you've expended. "What'll we do?"
+</p>
+
+<p>
+"We carry him," Ace said grimly. "Grab ahold the left side of his belt." He grabbed the right side, we manhandled Flores to his feet. "Lock on! Now... by the numbers, stand by to jump — one — two!"
+</p>
+
+<p>
+We jumped. Not far, not well. One man alone couldn't have gotten him off the ground; an armored suit is too heavy. But split it between two men and it can be done.
+We jumped — and we jumped — and again, and again, with Ace calling it and both of us steadying and catching Dizzy on each grounding. His gyros seemed to be out.
+</p>
+
+<p>
+We heard the beacon cut off as the retrieval boat landed on it — I saw it land . . . and it was too far away. We heard the acting platoon sergeant call out: "In succession, prepare to embark!"
+</p>
+
+<p>
+And Jelly called out, "Belay that order!"
+</p>
+
+<p>
+We broke at last into the open and saw the boat standing on its tail, heard the ululation of its take-off warning — saw the platoon still on the ground around it, in interdiction circle, crouching behind the shield they had formed. Heard Jelly shout, "In succession, man the boat — move!"
+</p>
+
+<p>
+And we were still too far away! I could see them peel off from the first squad, swarm into the boat as the interdiction circle tightened. And a single figure broke out of the circle, came toward us at a speed possible only to a command suit. Jelly caught us while we were in the air, grabbed Flores by his Y-rack and helped us lift. Three jumps got us to the boat. Everybody else was inside but the door was still open. We got him in and closed it while the boat pilot screamed that we had made her miss rendezvous and now we had all bought it! Jelly paid no attention to her; we laid Flores down and lay down beside him. As the blast hit us Jelly was saying to himself, "All present, Lieutenant. Three men hurt — but all present!"
+</p>
+
+<p>
+I'll say this for Captain Deladrier: they don't make any better pilots. A rendezvous, boat to ship in orbit, is precisely calculated. I don't know how, but it is, and you don't change it. You can't.
+</p>
+
+<p>
+Only she did. She saw in her scope that the boat had failed to blast on time; she braked back, picked up speed again — and matched and took us in, just by eye and touch, no time to compute it. If the Almighty ever needs an assistant to keep the stars in their courses, I know where he can look.
+</p>
+
+<p>
+Flores died on the way up.
+</p>
+
+<p>
+ -- repeat --
+</p>
+
+<p>
+Then suddenly nothing. Nothing at all. No sound, no pressure, no weight. Floating in darkness... free fall, maybe thirty miles up, above the effective atmosphere, falling weightlessly toward the surface of a planet you've never seen. But I'm not shaking now; it's the wait beforehand that wears. Once you unload, you can't get hurt — because if anything goes wrong it will happen so fast that you'll buy it without noticing that you're dead, hardly.
+</p>
+
+<p>
+Almost at once I felt the capsule twist and sway, then steady down so that my weight was on my back...weight that built up quickly until I was at my full weight (0.87 gee, we had been told) for that planet as the capsule reached terminal velocity for the thin upper atmosphere. A pilot who is a real artist (and the Captain was) will approach and brake so that your launching speed as you shoot out of the tube places you just dead in space relative to the rotational speed of the planet at that latitude. The loaded capsules are heavy; they punch through the high, thin winds of the upper atmosphere without being blown too far out of position — but just the same a platoon is bound to disperse on the way down, lose some of the perfect formation in which it unloads. A sloppy pilot can make this still worse, scatter a strike group over so much terrain that it can't make rendezvous for retrieval, much less carry out its mission. An infantryman can fight only if somebody else delivers him to his zone; in a way I suppose pilots are just as essential as we are.
+</p>
+
+<p>
+I could tell from the gentle way my capsule entered the atmosphere that the Captain had laid us down with as near zero lateral vector as you could ask for. I felt happy — not only a tight formation when we hit and no time wasted, but also a pilot who puts you down properly is a pilot who is smart and precise on retrieval.
+</p>
+
+<p>
+The outer shell burned away and sloughed off — unevenly, for I tumbled. Then the rest of it went and I straightened out. The turbulence brakes of the second shell bit in and the ride got rough... and still rougher as they burned off one at a time and the second shell began to go to pieces. One of the things that helps a capsule trooper to live long enough to draw a pension is that the skins peeling off his capsule not only slow him down, they also fill the sky over the target area with so much junk that radar picks up reflections from dozens of targets for each man in the drop, any one of which could be a man, or a bomb, or anything. It's enough to give a ballistic computer nervous breakdowns — and does. To add to the fun your ship lays a series of dummy eggs in the seconds immediately following your drop, dummies that will fall faster because they don't slough. They get under you, explode, throw out "window," even operate as transponders, rocket sideways, and do other things to add to the confusion of your reception committee on the ground.
+</p>
+
+<p>
+In the meantime your ship is locked firmly on the directional beacon of your platoon leader, ignoring the radar "noise" it has created and following you in, computing your impact for future use. When the second shell was gone, the third shell automatically opened my first ribbon chute. It didn't last long but it wasn't expected to; one good, hard jerk at several gee and it went its way and I went mine. The second chute lasted a little bit longer and the third chute lasted quite a while; it began to be rather too warm inside the capsule and I started thinking about landing.
+</p>
+
+<p>
+The third shell peeled off when its last chute was gone and now I had nothing around me but my suit armor and a plastic egg. I was still strapped inside it, unable to move; it was time to decide how and where I was going to ground. Without moving my arms (I couldn't) I thumbed the switch for a proximity reading and read it when it flashed on in the instrument reflector inside my helmet in front of my forehead. A mile and eight-tenths — A little closer than I liked, especially without company. The inner egg had reached steady speed, no more help to be gained by staying inside it, and its skin temperature indicated that it would not open automatically for a while yet — so I flipped a switch with my other thumb and got rid of it.
+</p>
+
+<p>
+The first charge cut all the straps; the second charge exploded the plastic egg away from me in eight separate pieces — and I was outdoors, sitting on air, and could see! Better still, the eight discarded pieces were metal-coated (except for the small bit I had taken proximity reading through) and would give back the same reflection as an armored man. Any radar viewer, alive or cybernetic, would now have a sad time sorting me out from the junk nearest me, not to mention the thousands of other bits and pieces for miles on each side, above, and below me. Part of a mobile infantryman's training is to let him see, from the ground and both by eye and by radar, just how confusing a drop is to the forces on the ground — because you feel awful naked up there. It is easy to panic and either open a chute too soon and become a sitting duck (do ducks really sit? — if so, why?) or fail to open it and break your ankles, likewise backbone and skull. So I stretched, getting the kinks out, and looked around... then doubled up again and straightened out in a swan dive face down and took a good look. It was night down there, as planned, but infrared snoopers let you size up terrain quite well after you are used to them. The river that cut diagonally through the city was almost below me and coming up fast, shining out clearly with a higher temperature than the land. I didn't care which side of it I landed on but I didn't want to land in it; it would slow me down.
+</p>
+
+<p>
+I noticed a dash off to the right at about my altitude; some unfriendly native down below had burned what was probably a piece of my egg. So I fired my first chute at once, intending if possible to jerk myself right off his screen as he followed the targets down in closing range. I braced for the shock, rode it, then floated down for about twenty seconds before unloading the chute — not wishing to call attention to myself in still another way by not falling at the speed of the other stuff around me. It must have worked; I wasn't burned.
+</p>
+
+<p>
+About six hundred feet up I shot the second chute... saw very quickly that I was being carried over into the river, found that I was going to pass about a hundred feet up over a flat-roofed warehouse or some such by the river... blew the chute free and came in for a good enough if rather bouncy landing on the roof by means of the suit's jump jets. I was scanning for Sergeant Jelal's beacon as I hit. And found that I was on the wrong side of the river; Jelly's star showed up on the compass ring inside my helmet far south of where it should have been — I was too far north. I trotted toward the river side of the roof as I took a range and bearing on the squad leader next to me, found that he was over a mile out of position, called, "Ace! dress your line," tossed a bomb behind me as I stepped off the building and across the river. Ace answered as I could have expected — Ace should have had my spot but he didn't want to give up his squad; nevertheless he didn't fancy taking orders from me.
+</p>
+
+<p>
+The warehouse went up behind me and the blast hit me while I was still over the river, instead of being shielded by the buildings on the far side as I should have been. It darn near tumbled my gyros and I came close to tumbling myself. I had set that bomb for fifteen seconds... or had I? I suddenly realized that I had let myself get excited, the worst thing you can do once you're on the ground. "Just like a drill," that was the way, just as Jelly had warned me. Take your time and do it right, even if it takes another half second. As I hit I took another reading on Ace and told him again to realign his squad. He didn't answer but he was already doing it. I let it ride. As long as Ace did his job, I could afford to swallow his surliness — for now. But back aboard ship (if Jelly kept me on as assistant section leader) we would eventually have to pick a quiet spot and find out who was boss. He was a career corporal and I was just a term lance acting as corporal, but he was under me and you can't afford to take any lip under those circumstances. Not permanently.
+</p>
+
+<p>
+But I didn't have time then to think about it; while I was jumping the river I had spotted a juicy target and I wanted to get it before somebody else noticed it — a lovely big group of what looked like public buildings on a hill. Temples, maybe... or a palace. They were miles outside the area we were sweeping, but one rule of a smash & run is to expend at least half your ammo outside your sweep area; that way the enemy is kept confused as to where you actually are — that and keep moving, do everything fast. You're always heavily outnumbered; surprise and speed are what saves you. I was already loading my rocket launcher while I was checking on Ace and telling him for the second time to straighten up. Jelly's voice reached me right on top of that on the all-hands circuit: "Platoon! By leapfrog! Forward!" My boss, Sergeant Johnson, echoed, "By leapfrog! Odd numbers! Advance!" That left me with nothing to worry about for twenty seconds, so I jumped up on the building nearest me, raised the launcher to my shoulder, found the target and pulled the first trigger to let the rocket have a look at its target — pulled the second trigger and kissed it on its way, jumped back to the ground. "Second section, even numbers!" I called out... waited for the count in my mind and ordered, "Advance!"
+</p>
+
+<p>
+And did so myself, hopping over the next row of buildings, and, while I was in the air, fanning the first row by the river front with a hand flamer. They seemed to be wood construction and it looked like time to start a good fire — with luck, some of those warehouses would house oil products, or even explosives. As I hit, the Y-rack on my shoulders launched two small H. E. bombs a couple of hundred yards each way to my right and left flanks but I never saw what they did as just then my first rocket hit — that unmistakable (if you've ever seen one) brilliance of an atomic explosion. It was just a peewee, of course, less than two kilotons nominal yield, with tamper and implosion squeeze to produce results from a less-than-critical mass — but then who wants to be bunk mates with a cosmic catastrophe? It was enough to clean off that hilltop and make everybody in the city take shelter against fallout. Better still, any of the local yokels who happened to be outdoors and looking that way wouldn't be seeing anything else for a couple of hours — meaning me. The dash hadn't dazzled me, nor would it dazzle any of us; our face bowls are heavily leaded, we wear snoopers over our eyes — and we're trained to duck and take it on the armor if we do happen to be looking the wrong way.
+</p>
+
+<p>
+So I merely blinked hard — opened my eyes and stared straight at a local citizen just coming out of an opening in the building ahead of me. He looked at me, I looked at him, and he started to raise something — a weapon, I suppose — as Jelly called out, "Odd numbers! Advance!"
+</p>
+
+<p>
+I didn't have time to fool with him; I was a good five hundred yards short of where I should have been by then. I still had the hand flamer in my left hand; I toasted him and jumped over the building he had been coming out of, as I started to count. A hand flamer is primarily for incendiary work but it is a good defensive anti-personnel weapon in tight quarters; you don't have to aim it much.
+</p>
+
+<p>
+Between excitement and anxiety to catch up I jumped too high and too wide. It's always a temptation to get the most out of your jump gear — but don't do it! It leaves you hanging in the air for seconds, a big fat target. The way to advance is to skim over each building as you come to it, barely clearing it, and taking full advantage of cover while you're down — and never stay in one place more than a second or two, never give them time to target in on you. Be somewhere else, anywhere. Keep moving.
+</p>
+
+<p>
+</p>
+
+<p>This one I goofed — too much for one row of buildings, too little for the row beyond it; I found myself coming down on a roof. But not a nice flat one where I might have tarried three seconds to launch another peewee A-rocket; this roof was a jungle of pipes and stanchions and assorted ironmongery — a factory maybe, or some sort of chemical works. No place to land. Worse still, half a dozen natives were up there. These geezers are humanoid, eight or nine feet tall, much skinnier than we are and with a higher body temperature; they don't wear any clothes and they stand out in a set of snoopers like a neon sign. They look still funnier in daylight with your bare eyes but I would rather fight them than the arachnids — those Bugs make me queezy.
+</p>
+
+<p>
+If these laddies were up there thirty seconds earlier when my rocket hit, then they couldn't see me, or anything. But I couldn't be certain and didn't want to tangle with them in any case; it wasn't that kind of a raid. So I jumped again while I was still in the air, scattering a handful of ten-second fire pills to keep
+them busy, grounded, jumped again at once, and called out, "Second section! Even numbers!...Advance!" and kept right on going to close the gap, while trying to spot, every time I jumped, something worth expending a rocket on. I had three more of the little A-rockets and I certainly didn't intend to take any back with me.
+</p>
+
+<p>
+But I had had pounded into me that you must get your money's worth with atomic weapons — it was only the second time that I had been allowed to carry them. Right now I was trying to spot their waterworks; a direct hit on it could make the whole city uninhabitable, force them to evacuate it without directly killing anyone — just the sort of nuisance we had been sent down to commit. It should — according to the map we had studied under hypnosis — be about three miles upstream from where I was.
+</p>
+
+<p>
+But I couldn't see it; my jumps didn't take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+Fourth and Fifth squads answered, "Wilco"; Ace said, "We're already doin' it — pick up your feet." Red's beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+<p>
+At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I'm no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn't already been told to jump, I guess I wouldn't have got out of there.
+</p>
+
+<p>
+Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+<p>
+There was something on the horizon in the direction of their spaceport — administration & control, maybe, or possibly even a starship. Almost in line and about half as far away was an enormous structure which I couldn't identify even that loosely. The range to the spaceport was extreme but I let the rocket see it, said, "Go find it, baby!" and twisted its tail — slapped the last one in, sent it toward the nearer target, and jumped. That building took a direct hit just as I left it. Either a skinny had judged (correctly) that it was worth one of their buildings to try for one of us, or one of my own mates was getting mighty careless with fireworks. Either way, I didn't want to jump from that spot, even a skimmer; I decided to go through the next couple of buildings instead of over. So I grabbed the heavy flamer off my back as I hit and dipped the snoopers down over my eyes, tackled a wall in front of me with a knife beam at full power. A section of
+wall fell away and I charged in. And backed out even faster. I didn't know what it was I had cracked open. A congregation in church — a skinny flophouse —
+maybe even their defense headquarters. All I knew was that it was a very big room filled with more skinnies than I wanted to see in my whole life.
+</p>
+
+<p>
+Probably not a church, for somebody took a shot at me as I popped back out just a slug that bounced off my armor, made my ears ring, and staggered me without hurting me. But it reminded me that I wasn't supposed to leave without giving them a souvenir of my visit. I grabbed the first thing on my belt and lobbed it in — and heard it start to squawk. As they keep telling you in Basic, doing something constructive at once is better than figuring out the best thing to do hours later. By sheer chance I had done the right thing. This was a special bomb, one each issued to us for this mission with instructions to use them if we found ways to make them effective. The squawking I heard as I threw it was the bomb shouting in skinny talk (free translation): "I'm a thirty-second bomb! I'm a thirty-second bomb! Twenty-nine!... twenty-eight!... twenty-seven! — "It was supposed to frazzle their nerves. Maybe it did; it certainly frazzled mine. Kinder to shoot a man. I didn't wait for the countdown; I jumped, while I wondered whether they would find enough doors and windows to swarm out in time.
+</p>
+
+<p>
+I got a bearing on Red's blinker at the top of the jump and one on Ace as I grounded. I was falling behind again — time to hurry. But three minutes later we had closed the gap; I had Red on my left flank a half mile away. He reported it to Jelly. We heard Jelly's relaxed growl to the entire platoon: "Circle is closed, but the beacon is not down yet. Move forward slowly and mill around, make a little more trouble — but mind the lad on each side of you; don't make trouble for him. Good job, so far — don't spoil it. Platoon! By sections...Muster!"
+</p>
+
+<p>
+It looked like a good job to me, too; much of the city was burning and, although it was almost full light now, it was hard to tell whether bare eyes were better than snoopers, the smoke was so thick. Johnson, our section leader, sounded off: "Second section, call off!" I echoed, "Squads four, five, and six — call off and report!" The assortment of safe circuits we had available in the new model comm units certainly speeded things up; Jelly could talk to anybody or to his section leaders; a section leader could call his whole section, or his non-coms; and the platoon could muster twice as fast, when seconds matter. I listened to the fourth squad call off while I inventoried my remaining firepower and lobbed one bomb toward a skinny who poked his head around a corner. He left and so did I — "Mill around," the boss man had said.
+</p>
+
+<p>
+The fourth squad bumbled the call off until the squad leader remembered to fill in with Jenkins' number; the fifth squad clicked off like an abacus and I began to feel good . . . when the call off stopped after number four in Ace's squad. I called out, "Ace, where's Dizzy?"
+</p>
+
+<p>
+"Shut up," he said. "Number six! Call off!"
+</p>
+
+<p>
+"Six!" Smith answered.
+</p>
+
+<p>
+"Seven!"
+</p>
+
+<p>
+"Sixth squad, Flores missing," Ace completed it. "Squad leader out for pickup."
+</p>
+
+<p>
+"One man absent," I reported to Johnson. "Flores, squad six."
+</p>
+
+<p>
+"Missing or dead?"
+</p>
+
+<p>
+"I don't know. Squad leader and assistant section leader dropping out for pickup."
+</p>
+
+<p>
+"Johnnie, you let Ace take it."
+</p>
+
+<p>
+But I didn't hear him, so I didn't answer. I heard him report to Jelly and I heard Jelly cuss. Now look, I wasn't bucking for a medal — it's the assistant section leader's business to make pickup; he's the chaser, the last man in, expendable. The squad leaders have other work to do. As you've no doubt gathered by now the assistant section leader isn't necessary as long as the section leader is alive. Right that moment I was feeling unusually expendable, almost expended, because I was hearing the sweetest sound in the universe, the beacon the retrieval boat would land on, sounding our recall. The beacon is a robot rocket, fired ahead of the retrieval boat, just a spike that buries itself in the ground and starts broadcasting that welcome, welcome music. The retrieval boat homes in on it automatically three minutes later and you had better be on hand, because the bus can't wait and there won't be another one along.
+</p>
+
+<p>
+But you don't walk away on another cap trooper, not while there's a chance he's still alive — not in Rasczak's Roughnecks. Not in any outfit of the Mobile Infantry. You try to make pickup. I heard Jelly order: "Heads up, lads! Close to retrieval circle and interdict! On the bounce!"
+</p>
+
+<p>
+And I heard the beacon's sweet voice: " — to the everlasting glory of the infantry, shines the name, shines the name of Rodger Young!" and I wanted to head for it so bad I could taste it.
+</p>
+
+<p>
+Instead I was headed the other way, closing on Ace's beacon and expending what I had left of bombs and fire pills and anything else that would weigh me down. "Ace! You got his beacon?"
+</p>
+
+<p>
+"Yes. Go back, Useless!"
+</p>
+
+<p>
+"I've got you by eye now. Where is he?"
+</p>
+
+<p>
+"Right ahead of me, maybe quarter mile. Scram! He's my man ."
+</p>
+
+<p>
+I didn't answer; I simply cut left oblique to reach Ace about where he said Dizzy was.
+</p>
+
+<p>
+And found Ace standing over him, a couple of skinnies flamed down and more running away. I lit beside him. "Let's get him out of his armor — the boat'll be down any second!"
+</p>
+
+<p>
+"He's too bad hurt!"
+</p>
+
+<p>
+I looked and saw that it was true — there was actually a hole in his armor and blood coming out. And I was stumped. To make a wounded pickup you get him out of his armor... then you simply pick him up in your arms — no trouble in a powered suit — and bounce away from there. A bare man weighs less than the ammo and stuff you've expended. "What'll we do?"
+</p>
+
+<p>
+"We carry him," Ace said grimly. "Grab ahold the left side of his belt." He grabbed the right side, we manhandled Flores to his feet. "Lock on! Now... by the numbers, stand by to jump — one — two!"
+</p>
+
+<p>
+We jumped. Not far, not well. One man alone couldn't have gotten him off the ground; an armored suit is too heavy. But split it between two men and it can be done.
+We jumped — and we jumped — and again, and again, with Ace calling it and both of us steadying and catching Dizzy on each grounding. His gyros seemed to be out.
+</p>
+
+<p>
+We heard the beacon cut off as the retrieval boat landed on it — I saw it land . . . and it was too far away. We heard the acting platoon sergeant call out: "In succession, prepare to embark!"
+</p>
+
+<p>
+And Jelly called out, "Belay that order!"
+</p>
+
+<p>
+We broke at last into the open and saw the boat standing on its tail, heard the ululation of its take-off warning — saw the platoon still on the ground around it, in interdiction circle, crouching behind the shield they had formed. Heard Jelly shout, "In succession, man the boat — move!"
+</p>
+
+<p>
+And we were still too far away! I could see them peel off from the first squad, swarm into the boat as the interdiction circle tightened. And a single figure broke out of the circle, came toward us at a speed possible only to a command suit. Jelly caught us while we were in the air, grabbed Flores by his Y-rack and helped us lift. Three jumps got us to the boat. Everybody else was inside but the door was still open. We got him in and closed it while the boat pilot screamed that we had made her miss rendezvous and now we had all bought it! Jelly paid no attention to her; we laid Flores down and lay down beside him. As the blast hit us Jelly was saying to himself, "All present, Lieutenant. Three men hurt — but all present!"
+</p>
+
+<p>
+I'll say this for Captain Deladrier: they don't make any better pilots. A rendezvous, boat to ship in orbit, is precisely calculated. I don't know how, but it is, and you don't change it. You can't.
+</p>
+
+<p>
+Only she did. She saw in her scope that the boat had failed to blast on time; she braked back, picked up speed again — and matched and took us in, just by eye and touch, no time to compute it. If the Almighty ever needs an assistant to keep the stars in their courses, I know where he can look.
+</p>
+
+<p>
+Flores died on the way up.
+</p>
+
+</body>
+
+</html>
\ No newline at end of file
diff --git a/src/cachingpolicy/htdocs/index_med.html b/src/cachingpolicy/htdocs/index_med.html
new file mode 100644
index 0000000..491836a
--- /dev/null
+++ b/src/cachingpolicy/htdocs/index_med.html
@@ -0,0 +1,31 @@
+<html>
+
+<body>
+
+<p>
+	A text page. Here is some text:
+</p>
+
+<p>
+	But I couldn’t see it; my jumps didn’t take me high enough, maybe. I was tempted to go higher but I remembered what Migliaccio had said about not trying for a medal, and stuck to doctrine. I set the Y-rack launcher on automatic and let it lob a couple of little bombs every time I hit. I set fire to things more or less at random in between, and tried to find the waterworks, or some other worth-while target.
+</p>
+
+<p>
+	Well, there was something up there at the proper range — waterworks or whatever, it was big. So I hopped on top of the tallest building near me, took a bead on it, and let fly. As I bounced down I heard Jelly: "Johnnie! Red! Start bending in the flanks." I acknowledged and heard Red acknowledge and switched my beacon to blinker so that Red could pick me out for certain, took a range and bearing on his blinker while I called out, "Second Section! Curve in and envelop! Squad leaders acknowledge!"
+</p>
+
+<p>
+	Fourth and Fifth squads answered, "Wilco"; Ace said, "We’re already doin’ it — pick up your feet." Red’s beacon showed the right flank to be almost ahead of me and a good fifteen miles away. Golly! Ace was right; I would have to pick up my feet or I would never close the gap in time — and me with a couple of hundredweight of ammo and sundry nastiness still on me that I just had to find time to use up. We had landed in a V formation, with Jelly at the bottom of the V and Red and myself at the ends of the two arms; now we had to close it into a circle around the retrieval rendezvous... which meant that Red and I each had to cover more ground than the others and still do our full share of damage.
+</p>
+
+<p>
+	At least the leapfrog advance was over with once we started to encircle; I could quit counting and concentrate on speed. It was getting to be less healthy to be anywhere, even moving fast. We had started with the enormous advantage of surprise, reached the ground without being hit (at least I hoped nobody had been hit coming in), and had been rampaging in among them in a fashion that let us fire at will without fear of hitting each other while they stood a big chance of hitting their own people in shooting at us - if they could find us to shoot at, at all. (I’m no games-theory expert but I doubt if any computer could have analyzed what we were doing in time to predict where we would be next.) Nevertheless the home defenses were beginning to fight back, co-ordinated or not. I took a couple of near misses with explosives, close enough to rattle my teeth even inside armor and once I was brushed by some sort of beam that made my hair stand on end and half paralyzed me for a moment - as if I had hit my funny bone, but all over. If the suit hadn’t already been told to jump, I guess I wouldn’t have got out of there.
+</p>
+
+<p>
+	Things like that make you pause to wonder why you ever took up soldiering — only I was too busy to pause for anything. Twice, jumping blind over buildings, I landed right in the middle of a group of them — jumped at once while fanning wildly around me with the hand flamer. Spurred on this way, I closed about half of my share of the gap, maybe four miles, in minimum time but without doing much more than casual damage. My Y-rack had gone empty two jumps back; finding myself alone in sort of a courtyard I stopped to put my reserve H.E. bombs into it while I took a bearing on Ace — found that I was far enough out in front of the flank squad to think about expending my last two A-rockets. I jumped to the top of the tallest building in the neighborhood. It was getting light enough to see; I flipped the snoopers up onto my forehead and made a fast scan with bare eyes, looking for anything behind us worth shooting at, anything at all; I had no time to be choosy.
+</p>
+
+</body>
+
+</html>
\ No newline at end of file
diff --git a/src/cachingpolicy/htdocs/index_small.html b/src/cachingpolicy/htdocs/index_small.html
new file mode 100644
index 0000000..ded44a4
--- /dev/null
+++ b/src/cachingpolicy/htdocs/index_small.html
@@ -0,0 +1,11 @@
+<html>
+
+<body>
+
+<p>
+	A tiny text page.
+</p>
+
+</body>
+
+</html>
\ No newline at end of file
diff --git a/src/cachingpolicy/project/cachingpolicy/config.conf b/src/cachingpolicy/project/cachingpolicy/config.conf
new file mode 100644
index 0000000..4e013d8
--- /dev/null
+++ b/src/cachingpolicy/project/cachingpolicy/config.conf
@@ -0,0 +1,7 @@
+mutChance:60
+croChance:50
+binOpMutChance:40
+operandMutChance:30
+nthMostMutChance:30
+incrComplexityChance:75
+intRange:20
\ No newline at end of file
diff --git a/src/cachingpolicy/project/cachingpolicy/mutator.py b/src/cachingpolicy/project/cachingpolicy/mutator.py
new file mode 100644
index 0000000..71c010d
--- /dev/null
+++ b/src/cachingpolicy/project/cachingpolicy/mutator.py
@@ -0,0 +1,329 @@
+#!/usr/bin/python
+
+'''
+                             CachingPolicy 0.9                            
+                    Copyright (c) 2017 Ben Goldsworthy (rumps)                   
+                                                                               
+    CachingPolicy is an EmerGen(e)tic module for testing the use of genetic
+	algorithms as applied to the cache updating behaviour of a web server.
+                                                                            
+    This file is part of the CachingPolicy EmerGen(e)tic module.
+	
+	CachingPolicy 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.                                        
+																			   
+	CachingPolicy 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 CachingPolicy.  If not, see <http://www.gnu.org/licenses/>.     
+'''
+
+import fileinput
+import math
+import random
+import shutil
+import sys
+import os
+
+# This script generates the initial population of candidate programs,
+# and performs mutation/crossover for each subsequent generation.
+
+# Mutation probability variables, to be read in from the config file upon the 
+# first run of the mutation/crossover methods.
+# 0: Mutation chance
+# 1: Crossover chance
+# 2: Binary Operator Mutation chance
+# 3: Operand Mutation chance
+# 4: nthMost* Mutation chance
+# 5: Create Subtree Mutation chance
+
+probabilities = [None for x in range(6)]
+
+with open("./project/cachingpolicy/config.conf") as inFile:
+	for i, line in enumerate(inFile):
+		if i == 6:
+			intRange = int(line.partition(":")[2])	
+
+binaryOperators = ["*", "+", "-", "/"]
+operands = [str(n) for n in range(intRange)]
+for n in range(intRange):
+	operands.append("nthMostRecentlyUsed(0)")
+	operands.append("nthMostFrequentlyUsed(0)")
+operands.append("random()")
+verbose = False
+script = ""
+
+def getSubLists(lst):
+	"""Recursively gets every sub-tree of a given expression."""
+	subLists = []
+	for token in lst:
+		if isinstance(token, list):
+			subLists.append(token)
+			if getSubLists(token) is not None:
+				subLists.append(getSubLists(token)[0])
+	if len(subLists) == 0: return None
+	elif len(subLists) == 1: return subLists[0]
+	else: return subLists
+	
+def crossover(parentA, parentB):
+	"""Crosses over a random subtree from chromosome A to a random point on
+	chromosome B."""
+	if verbose: print("\tCrossover: Parent A (", compile(parentA), ") x Parent B (", compile(parentB), ")")
+	
+	subTrees = []
+	for i, token in enumerate(parentA):
+		if isinstance(token, list):
+			subTrees.append(token)
+			subLists = getSubLists(token)
+			if subLists is not None:
+				subTrees.append(subLists)
+	
+	changePoint = []
+	
+	temp = 0
+	while 1:
+		# DEBUG - trying to avoid the endless loop error, if this is the cause.
+		temp += 1
+		if temp > 1000: break
+		#/DEBUG
+		changePoint = random.choice(parentB)
+		if not isinstance(changePoint, list):
+			if str(changePoint).isnumeric():
+				break
+	if len(subTrees) > 0:
+		newSubTree = random.choice(subTrees)
+		if verbose: print("\t\tResult: "+compile(newSubTree)+" replaced operand "+changePoint+" ("+compile([newSubTree if x==changePoint else x for x in parentB])+")")
+		return [newSubTree if x==changePoint else x for x in parentB]
+	else: return [parentB]
+	
+def mutate(chromosome, initialPop = None):
+	"""Recursively applies, to each token, a random chance of mutating 
+	a given operand, operator, or replacing the former with an entirely 
+	new expression."""	
+	if probabilities[2] is None:
+		with open("./project/cachingpolicy/config.conf") as inFile:
+			for i, line in enumerate(inFile):
+				if i < 6 and i > 1:
+					probabilities[i] = int(line.partition(":")[2])
+			
+	operandMutChance = 100 if initialPop else probabilities[3]
+	
+	for i, token in enumerate(chromosome):
+		if verbose: print("\tMutating: "+compile(chromosome))
+		token = str(token)
+		
+		if len(chromosome) < 3:
+			if random.randrange(100) < probabilities[5]:# and "nthMost" not in token:
+				if len(chromosome) == 1:
+					chromosome.append(random.choice(binaryOperators))
+					chromosome.append(random.randrange(intRange))
+				elif random.randrange(100) < 50:
+					chromosome.remove(chromosome[0])
+				else:
+					chromosome[1] = [random.choice(operands), random.choice(binaryOperators), random.choice(operands)] 
+					
+		else:
+			if isinstance(token, list):
+				chromosome[i] = mutate(token)
+				
+			if token in binaryOperators and random.randrange(100) < probabilities[2]:
+				chromosome[i] = random.choice(binaryOperators)
+			elif token.isnumeric() and random.randrange(100) < operandMutChance:
+				chromosome[i] = random.choice(operands)
+		'''
+		elif "nthMost" in token and random.randrange(100) < probabilities[4]:
+			if random.randrange(100) < 50:
+				chromosome[i] = "nthMostRecentlyUsed" if token == "nthMostFrequentlyUsed" else "nthMostFrequentlyUsed"
+			else:
+				chromosome.remove(token)
+		'''
+		if verbose: print("\t\tResult: "+compile(chromosome))
+	
+	return chromosome
+	
+def parse(chromosome):
+	"""Given a `str` representation of a chromosome, recursively parses
+	it into a `List`."""
+	i = 0
+	counter = 0
+	substring = ""
+	result = []
+	while i < len(chromosome):
+		if chromosome[i] is "r":
+			i += len("random()")
+			result.append("random()")
+		elif chromosome[i] is "n":
+			function = ""
+			if chromosome[i+7] is "F":
+				function = "nthMostFrequentlyUsed"
+			elif chromosome[i+7] is "R":
+				function = "nthMostRecentlyUsed"
+			i += len(function)-1
+			result.append(function)
+		elif chromosome[i] is "(":
+			substring = ""
+			for j in chromosome[i:]:
+				if j is "(":
+					counter += 1
+				elif j is ")":
+					counter -= 1
+				substring += j
+				if counter == 0:
+					result.append(parse(substring[1:(len(substring)-1)]))
+					i += len(substring) - 1
+					break
+		elif chromosome[i].isnumeric():
+			num = ""
+			while chromosome[i].isnumeric():
+				num += chromosome[i]
+				i += 1
+				if i == len(chromosome):
+					break
+			if len(num) > 0:
+				i -= 1
+			result.append(num)
+		elif chromosome[i] in binaryOperators:
+			result.append(chromosome[i])
+		i += 1
+	return result
+
+def compile(chromosome):
+	"""Given a `List` representation of a chromosome, recursively compiles 
+	it into a `str`."""
+	string = ""
+	for i in chromosome:
+		if isinstance(i, list):
+			string += "("
+			string += compile(i)
+			string += ")"
+		else:
+			string += str(i)
+	return string
+	
+def createInitialPop(candidates):
+	"""Creates the initial population for generation 0."""
+	for i in range(candidates):
+		cID = "0_"+str(i)
+		shutil.copyfile("./cache/CacheHandlerBase.dn", "./cache/"+script+"/0/CacheHandler"+cID+".dn")
+		writeChromosomeToFile(cID, parse(readChromosomeFromFile(cID)))
+		os.system("dnc ./cache/"+script+"/0/CacheHandler"+cID+".dn")
+		
+def readChromosomeFromFile(cID):
+	"""Reads the chromosome from a given `CacheHandler*.dn` file."""
+	with open("./cache/"+script+"/"+str(cID.partition("_")[0])+"/CacheHandler"+cID+".dn") as inFile:
+		for line in inFile:
+			if "// BEGIN" in line:
+				return next(inFile).partition(" = ")[2].rstrip()
+			
+def writeChromosomeToFile(cID, chromosome):
+	"""Writes a given chromosome to a `CacheHandler*.dn` file."""
+	shutil.copyfile("./cache/CacheHandlerBase.dn", "./cache/"+script+"/"+str(cID.partition("_")[0])+"/CacheHandler"+cID+".dn.temp")
+	with open("./cache/"+script+"/"+str(cID.partition("_")[0])+"/CacheHandler"+cID+".dn.temp") as inFile:
+		with open("./cache/"+script+"/"+str(cID.partition("_")[0])+"/CacheHandler"+cID+".dn", "w") as outFile:
+			for line in inFile:
+				outFile.write(line)
+				if "// BEGIN" in line:
+					outFile.write("\t\t\t\tindex = "+compile(chromosome[0])+"\n")
+					next(inFile)
+	os.remove("./cache/"+script+"/"+str(cID.partition("_")[0])+"/CacheHandler"+cID+".dn.temp")
+
+def hasSubTrees(chromosome):
+	for x in chromosome[0]:
+		if isinstance(x, list): return True
+	else: return False
+
+def main(args):
+	random.seed()
+	
+	tabLevel = ""
+	chromosome = []
+	generation = int(args[0])
+	candidates = int(args[1])
+	chromosomes = []
+	newChromosomes = []
+	global script
+	script = args[3]
+	global verbose
+	verbose = True if int(args[2]) == 1 else False
+	
+	if generation == 0:
+		createInitialPop(candidates)
+	else:
+		# Gets all of the previous generation's chromosomes.
+		for i in range(candidates):
+			oldCID = str(generation - 1) + "_" + str(i)
+			chromosomes.append((parse(readChromosomeFromFile(oldCID)), oldCID))
+		
+		# Reads in the results of the previous generation's chromosomes.
+		rankSelect = []
+		with open("./results/"+script+"/results"+str(generation-1)+".txt") as inFile:
+			for line in inFile:
+				rankSelect.append([line.partition(":")[0], line.partition(":")[2].partition("ms")[0]])
+		# Sorts them by response time
+		rankSelect.sort(key=lambda x: int(x[1]))
+		# Truncates the bottom 90% of the candidates
+		del rankSelect[int(math.ceil(candidates/10)):]
+		
+		remainingIDs = [str(n) for n in range(candidates)]
+		
+		# Retains the top 10% best-peforming chromosomes for the next 
+		# generation.
+		if verbose: print("\nApplying rank selection to top 10% from prev. generation...")
+		for currCandidate, oldCID in enumerate(rankSelect):
+			newCID = str(generation) + "_" + str(oldCID[0].partition("_")[2])
+			for chromosome in chromosomes:
+				if chromosome[1] == oldCID[0]:
+					if verbose: print("\tResult: "+str(oldCID[0])+" copied to "+newCID)
+					newChromosome = [chromosome[0], newCID]
+					newChromosomes.append(newChromosome)
+					#chromosomes.remove(chromosome)
+					remainingIDs.remove(newCID.partition("_")[2])
+					break
+		if verbose: print("\n")
+		
+		if probabilities[0] is None:
+			with open("./project/cachingpolicy/config.conf") as inFile:
+				for i, line in enumerate(inFile):
+					if i > 1: break
+					probabilities[i] = int(line.partition(":")[2])
+		
+		# For the remaining chromosomes, creates the next generation's
+		# population, whilst having a chance to affect mutation or
+		# crossover operations on each.
+		for currCandidate, chromosome in enumerate(chromosomes):
+			if str(currCandidate) in remainingIDs:
+				newCID = str(generation) + "_" + str(currCandidate)
+				
+				newChromosome = [chromosome[0], newCID]
+				if random.randrange(100) < probabilities[0]:
+					haveSubTrees = [x for x in chromosomes if hasSubTrees(x)]
+					if len(haveSubTrees) > 1:
+						parentB = random.choice(haveSubTrees)[0]
+						if hasSubTrees(chromosome[0]):
+							if verbose: print("Crossing over into "+newCID)
+							newChromosome = [crossover(chromosome[0], parentB, verbose), newCID]
+							if verbose: print("Crossover finish.")
+							
+				if random.randrange(100) < probabilities[1]:
+					if verbose: print("Mutating "+str(generation-1) + "_" + str(currCandidate)+"->"+newCID+":")
+					newChromosome = [mutate(chromosome[0], True), newCID]
+					if verbose: print(str(generation-1) + "_" + str(currCandidate)+"->"+newCID+" mutation finish.\n")
+					
+					
+				newChromosomes.append(newChromosome)
+		
+		# Writes this new population to `.dn` files, and then runs the
+		# Dana compiler on the.
+		for currCandidate, chromosome in enumerate(newChromosomes):
+			newCID = str(generation) + "_" + str(currCandidate)
+			writeChromosomeToFile(newCID, chromosome)
+			os.system("dnc ./cache/"+script+"/"+str(newCID.partition("_")[0])+"/CacheHandler"+newCID+".dn")
+	return 0
+	
+if __name__ == '__main__':
+	sys.exit(main(sys.argv[1:]))
diff --git a/src/cachingpolicy/project/cachingpolicy/setup.sh b/src/cachingpolicy/project/cachingpolicy/setup.sh
new file mode 100644
index 0000000..4c9c6aa
--- /dev/null
+++ b/src/cachingpolicy/project/cachingpolicy/setup.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+# Performs pre-run setup before a test run.
+
+GENS=$1
+SCRIPT=$2
+
+cp ./cachebackup/CacheHandlerBase.dn ./cache/CacheHandlerBase.dn
+mkdir ./cache/$2
+mkdir ./results/$2
+for i in `seq 0 $1`; do
+	mkdir ./cache/$2/$i
+   touch ./results/$2/results$i.txt
+done
diff --git a/src/cachingpolicy/resources/cache/CacheHandler.dn b/src/cachingpolicy/resources/cache/CacheHandler.dn
new file mode 100644
index 0000000..ae0a465
--- /dev/null
+++ b/src/cachingpolicy/resources/cache/CacheHandler.dn
@@ -0,0 +1,36 @@
+uses time.DateTime
+
+data CachedResponse {
+	char command[]
+	char resource[]
+	char mimeType[]
+
+	byte response[]
+
+	// the age of resource (when the content was created/last updated)
+	DateTime resourceAge
+	
+	// Roberto: don't know what this is for
+	// Barry created this variable ...
+	int users
+
+	// this is to keep track of number of hits
+	int hits
+	DateTime lastUsed
+
+	int contentSize// size in byte of the actual content (without header)
+
+	// the time the resource was added to the cache
+	DateTime timeAdded
+
+	CachedResponse next
+	CachedResponse prev
+}
+
+interface CacheHandler {
+	const int MAX_SIZE = 100
+
+	CachedResponse getCachedResponse(char resource[])
+	void updateCache(CachedResponse ncr)
+	void clearCache()
+}
diff --git a/src/emergenetic/LICENSE.md b/src/emergenetic/LICENSE.md
new file mode 100644
index 0000000..2a99aee
--- /dev/null
+++ b/src/emergenetic/LICENSE.md
@@ -0,0 +1,675 @@
+### GNU GENERAL PUBLIC LICENSE
+
+Version 3, 29 June 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc.
+<http://fsf.org/>
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+### Preamble
+
+The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom
+to share and change all versions of a program--to make sure it remains
+free software for all its users. We, the Free Software Foundation, use
+the GNU General Public License for most of our software; it applies
+also to any other work released this way by its authors. You can apply
+it to your programs, too.
+
+When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights. Therefore, you
+have certain responsibilities if you distribute copies of the
+software, or if you modify it: responsibilities to respect the freedom
+of others.
+
+For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received. You must make sure that they, too, receive
+or can get the source code. And you must show them these terms so they
+know their rights.
+
+Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software. For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the
+manufacturer can do so. This is fundamentally incompatible with the
+aim of protecting users' freedom to change the software. The
+systematic pattern of such abuse occurs in the area of products for
+individuals to use, which is precisely where it is most unacceptable.
+Therefore, we have designed this version of the GPL to prohibit the
+practice for those products. If such problems arise substantially in
+other domains, we stand ready to extend this provision to those
+domains in future versions of the GPL, as needed to protect the
+freedom of users.
+
+Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish
+to avoid the special danger that patents applied to a free program
+could make it effectively proprietary. To prevent this, the GPL
+assures that patents cannot be used to render the program non-free.
+
+The precise terms and conditions for copying, distribution and
+modification follow.
+
+### TERMS AND CONDITIONS
+
+#### 0. Definitions.
+
+"This License" refers to version 3 of the GNU General Public License.
+
+"Copyright" also means copyright-like laws that apply to other kinds
+of works, such as semiconductor masks.
+
+"The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of
+an exact copy. The resulting work is called a "modified version" of
+the earlier work or a work "based on" the earlier work.
+
+A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user
+through a computer network, with no transfer of a copy, is not
+conveying.
+
+An interactive user interface displays "Appropriate Legal Notices" to
+the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+#### 1. Source Code.
+
+The "source code" for a work means the preferred form of the work for
+making modifications to it. "Object code" means any non-source form of
+a work.
+
+A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+The Corresponding Source need not include anything that users can
+regenerate automatically from other parts of the Corresponding Source.
+
+The Corresponding Source for a work in source code form is that same
+work.
+
+#### 2. Basic Permissions.
+
+All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+You may make, run and propagate covered works that you do not convey,
+without conditions so long as your license otherwise remains in force.
+You may convey covered works to others for the sole purpose of having
+them make modifications exclusively for you, or provide you with
+facilities for running those works, provided that you comply with the
+terms of this License in conveying all material for which you do not
+control copyright. Those thus making or running the covered works for
+you must do so exclusively on your behalf, under your direction and
+control, on terms that prohibit them from making any copies of your
+copyrighted material outside their relationship with you.
+
+Conveying under any other circumstances is permitted solely under the
+conditions stated below. Sublicensing is not allowed; section 10 makes
+it unnecessary.
+
+#### 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such
+circumvention is effected by exercising rights under this License with
+respect to the covered work, and you disclaim any intention to limit
+operation or modification of the work as a means of enforcing, against
+the work's users, your or third parties' legal rights to forbid
+circumvention of technological measures.
+
+#### 4. Conveying Verbatim Copies.
+
+You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+#### 5. Conveying Modified Source Versions.
+
+You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these
+conditions:
+
+-   a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+-   b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under
+    section 7. This requirement modifies the requirement in section 4
+    to "keep intact all notices".
+-   c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy. This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged. This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+-   d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+#### 6. Conveying Non-Source Forms.
+
+You may convey a covered work in object code form under the terms of
+sections 4 and 5, provided that you also convey the machine-readable
+Corresponding Source under the terms of this License, in one of these
+ways:
+
+-   a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+-   b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the Corresponding
+    Source from a network server at no charge.
+-   c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source. This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+-   d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge. You need not require recipients to copy the
+    Corresponding Source along with the object code. If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source. Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+-   e) Convey the object code using peer-to-peer transmission,
+    provided you inform other peers where the object code and
+    Corresponding Source of the work are being offered to the general
+    public at no charge under subsection 6d.
+
+A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal,
+family, or household purposes, or (2) anything designed or sold for
+incorporation into a dwelling. In determining whether a product is a
+consumer product, doubtful cases shall be resolved in favor of
+coverage. For a particular product received by a particular user,
+"normally used" refers to a typical or common use of that class of
+product, regardless of the status of the particular user or of the way
+in which the particular user actually uses, or expects or is expected
+to use, the product. A product is a consumer product regardless of
+whether the product has substantial commercial, industrial or
+non-consumer uses, unless such uses represent the only significant
+mode of use of the product.
+
+"Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to
+install and execute modified versions of a covered work in that User
+Product from a modified version of its Corresponding Source. The
+information must suffice to ensure that the continued functioning of
+the modified object code is in no case prevented or interfered with
+solely because modification has been made.
+
+If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or
+updates for a work that has been modified or installed by the
+recipient, or for the User Product in which it has been modified or
+installed. Access to a network may be denied when the modification
+itself materially and adversely affects the operation of the network
+or violates the rules and protocols for communication across the
+network.
+
+Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+#### 7. Additional Terms.
+
+"Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders
+of that material) supplement the terms of this License with terms:
+
+-   a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+-   b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+-   c) Prohibiting misrepresentation of the origin of that material,
+    or requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+-   d) Limiting the use for publicity purposes of names of licensors
+    or authors of the material; or
+-   e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+-   f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions
+    of it) with contractual assumptions of liability to the recipient,
+    for any liability that these contractual assumptions directly
+    impose on those licensors and authors.
+
+All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions; the
+above requirements apply either way.
+
+#### 8. Termination.
+
+You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+However, if you cease all violation of this License, then your license
+from a particular copyright holder is reinstated (a) provisionally,
+unless and until the copyright holder explicitly and finally
+terminates your license, and (b) permanently, if the copyright holder
+fails to notify you of the violation by some reasonable means prior to
+60 days after the cessation.
+
+Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+#### 9. Acceptance Not Required for Having Copies.
+
+You are not required to accept this License in order to receive or run
+a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+#### 10. Automatic Licensing of Downstream Recipients.
+
+Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+#### 11. Patents.
+
+A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+A contributor's "essential patent claims" are all patent claims owned
+or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+A patent license is "discriminatory" if it does not include within the
+scope of its coverage, prohibits the exercise of, or is conditioned on
+the non-exercise of one or more of the rights that are specifically
+granted under this License. You may not convey a covered work if you
+are a party to an arrangement with a third party that is in the
+business of distributing software, under which you make payment to the
+third party based on the extent of your activity of conveying the
+work, and under which the third party grants, to any of the parties
+who would receive the covered work from you, a discriminatory patent
+license (a) in connection with copies of the covered work conveyed by
+you (or copies made from those copies), or (b) primarily for and in
+connection with specific products or compilations that contain the
+covered work, unless you entered into that arrangement, or that patent
+license was granted, prior to 28 March 2007.
+
+Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+#### 12. No Surrender of Others' Freedom.
+
+If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under
+this License and any other pertinent obligations, then as a
+consequence you may not convey it at all. For example, if you agree to
+terms that obligate you to collect a royalty for further conveying
+from those to whom you convey the Program, the only way you could
+satisfy both those terms and this License would be to refrain entirely
+from conveying the Program.
+
+#### 13. Use with the GNU Affero General Public License.
+
+Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+#### 14. Revised Versions of this License.
+
+The Free Software Foundation may publish revised and/or new versions
+of the GNU General Public License from time to time. Such new versions
+will be similar in spirit to the present version, but may differ in
+detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies that a certain numbered version of the GNU General Public
+License "or any later version" applies to it, you have the option of
+following the terms and conditions either of that numbered version or
+of any later version published by the Free Software Foundation. If the
+Program does not specify a version number of the GNU General Public
+License, you may choose any version ever published by the Free
+Software Foundation.
+
+If the Program specifies that a proxy can decide which future versions
+of the GNU General Public License can be used, that proxy's public
+statement of acceptance of a version permanently authorizes you to
+choose that version for the Program.
+
+Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+#### 15. Disclaimer of Warranty.
+
+THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT
+WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND
+PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
+DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
+CORRECTION.
+
+#### 16. Limitation of Liability.
+
+IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR
+CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
+ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT
+NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR
+LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM
+TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER
+PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+#### 17. Interpretation of Sections 15 and 16.
+
+If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+END OF TERMS AND CONDITIONS
+
+### How to Apply These Terms to Your New Programs
+
+If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these
+terms.
+
+To do so, attach the following notices to the program. It is safest to
+attach them to the start of each source file to most effectively state
+the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+        <one line to give the program's name and a brief idea of what it does.>
+        Copyright (C) <year>  <name of author>
+
+        This program 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/>.
+
+Also add information on how to contact you by electronic and paper
+mail.
+
+If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+        <program>  Copyright (C) <year>  <name of author>
+        This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+        This is free software, and you are welcome to redistribute it
+        under certain conditions; type `show c' for details.
+
+The hypothetical commands \`show w' and \`show c' should show the
+appropriate parts of the General Public License. Of course, your
+program's commands might be different; for a GUI interface, you would
+use an "about box".
+
+You should also get your employer (if you work as a programmer) or
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. For more information on this, and how to apply and follow
+the GNU GPL, see <http://www.gnu.org/licenses/>.
+
+The GNU General Public License does not permit incorporating your
+program into proprietary programs. If your program is a subroutine
+library, you may consider it more useful to permit linking proprietary
+applications with the library. If this is what you want to do, use the
+GNU Lesser General Public License instead of this License. But first,
+please read <http://www.gnu.org/philosophy/why-not-lgpl.html>.
\ No newline at end of file
diff --git a/src/emergenetic/README.md b/src/emergenetic/README.md
new file mode 100644
index 0000000..9ef75ed
--- /dev/null
+++ b/src/emergenetic/README.md
@@ -0,0 +1,46 @@
+# EmerGen(e)tic 1.0         
+
+## License
+
+EmerGen(e)tic is copyright © 2017 Ben Goldsworthy (rumperuu).
+                                                                          
+EmerGen(e)tic 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.                                        
+                                                                           
+EmerGen(e)tic 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 EmerGen(e)tic.  If not, see <http://www.gnu.org/licenses/>.                             
+
+## Contact
+
+Email: me@bengoldsworthy.uk
+
+## Description
+
+EmerGen(e)tic is a Dana framework for testing the use of genetic
+algorithms as applied to the components of an emergent system.
+
+## Usage
+
+After compiling the `emergenetic.dn` file, the program can be run. It
+expects four command-line arguments, and can take a fifth optional one. 
+
+The command is as follows:
+   `dana emergenetic <module> <script> <generations> <candidates> [verbose]`
+
+* <module> is the name of the module folder that you wish to use for your 
+tests.
+* <script> is the name of the script file for this particular test, located 
+within the `/scripts/` directory and without the trailing `.script` file 
+extension.
+* The <generations> and <candidates> arguments are the number of 
+generations to run the test for, and the number of candidates to produce 
+per generation.
+* The optional 'verbose' argument, if present, produces far more verbose 
+output text. This can be useful for debugging.
diff --git a/src/emergenetic/emergenetic.dn b/src/emergenetic/emergenetic.dn
new file mode 100644
index 0000000..29d198c
--- /dev/null
+++ b/src/emergenetic/emergenetic.dn
@@ -0,0 +1,167 @@
+/*
+ *                        EmerGen(e)tic 1.0                       
+ *             Copyright © 2017 Ben Goldsworthy (rumperuu)        
+ *                                                                      
+ * EmerGen(e)tic is a framework for researching the use of genetic
+ * algorithms in emergent systems.
+ *                                                                           
+ * This file is part of EmerGen(e)tic.                                         
+ *                                                                             
+ * EmerGen(e)tic 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.                                        
+ *                                                                            
+ * EmerGen(e)tic 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 EmerGen(e)tic.  If not, see <http://www.gnu.org/licenses/>.                             
+ */
+
+/**
+ ** This program runs the tests that are passed to it as command-line
+ ** arguments. It contains methods that can be easily overwritten for
+ ** creating new tests.
+ **/
+
+/**
+ **   @author  Ben Goldsworthy (rumperuu) <me@bengoldsworthy.uk>
+ **   @version 1.0
+ **/
+component provides App requires os.Run run, 
+                                   io.Output out, 
+                                   composition.Loader unloader,
+                                   composition.RecursiveLoader loader, 
+                                   time.Calendar calendar, 
+                                   time.DateUtil dateUtil, 
+                                   data.StringUtil stringUtil, 
+                                   data.IntUtil intUtil,
+                                   io.File,
+                                   io.TextFile {
+   
+   // Required arguments.
+   int argMod = 0
+   int argScript = argMod + 1
+   int argGens = argScript + 1
+   int argCans = argGens + 1
+   int minArgs = argCans + 1
+   
+   // Optional arguments.
+   int argVerb = minArgs
+   int maxArgs = minArgs + 1
+   
+   /**
+    **   Main method. Runs the generations and mutation. This method 
+    **   should not need to be modified.
+    **   
+    **   @param params The arguments the program is run with (e.g. 
+    **   the number of generations to run, and the population size per
+    **   generation, etc.)
+    **   @return The program exit code.
+    **/
+   int App:main(AppParam params[]) {
+      // Checks that there are enough passed array arguments, and that
+      // they are valid.
+      if ((params.arrayLength >= minArgs) && (params.arrayLength <= maxArgs)) {
+         if (stringUtil.isNumeric(params[argGens].string) && stringUtil.isNumeric(params[argCans].string)) {
+            // Assigns all of the command-line arguments to variables.
+            int generations = intUtil.intFromString(params[argGens].string)
+            int candidates = intUtil.intFromString(params[argCans].string)
+            char module[] = params[argMod].string
+            char script[] = params[argScript].string
+            int verbose = 0
+            if (params.arrayLength == maxArgs) {
+               if (params[argVerb].string == "verbose") {
+                  verbose = 1
+               }
+            }
+            
+            // Performs any initial setup.
+            RunStatus setupResult = run.execute("./project/$(module)/setup.sh $(intUtil.intToString(generations)) $(script)")
+            // Iterates through the generations, creating them and then
+            // testing each of their candidates.
+            for (int i = 0; i < generations; i++) {           
+               // Runs the per-generation mutator.
+               RunStatus result = run.execute("python3 ./project/$(module)/mutator.py $(intUtil.intToString(i)) $(intUtil.intToString(candidates)) $(intUtil.intToString(verbose)) $(script)")
+               // Runs the generation.
+               runGeneration(i, candidates, script)
+            }
+            
+            return 0
+         // If the 'generations' and 'candidates' arguments are non-numeric...
+         } else {
+            out.println("Invalid runtime arguments: Arguments <generation> and <candidates> must be integers.")
+            return 1
+         }
+      // If an invalid number of arguments are passed to the program...
+      } else {
+         out.println("Invalid runtime arguments: Program should be run as:\n\t`dana emergenetic <module> <script> <generations> <candidates>`\n\nProgram may also be run with optional `verbose` flag as final argument:\n\tdana emergenetic <module> <script> <generations> <candidates> verbose`")
+         return 1
+      }
+	}
+   
+   /**
+    **   Runs a generation of candidates. This method should not need to
+    **   be modified.
+    **   
+    **   @param generation The generation of the candidate.
+    **   @param candidates The total number of candidates.
+    **   @param script The name of the script file being used.
+    **/
+   void runGeneration(int generation, int candidates, char script[]) { 
+      File results
+      
+      out.println("")
+      // Runs through each candidate.
+      for (int j = 0; j < candidates; j++) runCandidate(generation, j, script)
+      
+      // For the end of the generation's candidates, appends a newline to
+      // the CSV file.
+      results = new File("./results/$(script)/results.csv", File.FILE_ACCESS_WRITE)
+      results.setPos(results.getSize())
+      results.write("\r\n")
+      results.close()
+   }
+    
+   /**
+    **   Runs a candidate through a test. Modify this method for changing
+    **   what is being tested.
+    **   
+    **   @param generation The generation of the candidate.
+    **   @param candidate The number of the candidate.
+    **   @param script The name of the script file being used.
+    **/
+   void runCandidate(int generation, int candidate, char script[]) {
+      // This method intentionally left blank.
+   }
+   
+   /**
+    **   Prints the results of a test run. This method should not need to
+    **   be modified.
+    **   
+    **   @param generation The generation of the candidate.
+    **   @param candidate The number of the candidate.
+    **   @param metric The value of the metric by which candidates are
+    **      being rated (as a string).
+    **   @param unit The unit of the value (e.g. ms, cm, etc.).
+    **   @param script The name of the script file being used.
+    **/
+   void printResults(int generation, int candidate, char metric[], char unit[], char script[]) {
+      File results
+      
+      out.println("Result for configuration $(intUtil.intToString(generation))x$(intUtil.intToString(candidate)): $(metric) $(unit)")
+      
+      results = new File("./results/$(script)/results$(intUtil.intToString(generation)).txt", File.FILE_ACCESS_WRITE)
+      results.setPos(results.getSize())
+      results.write("$(intUtil.intToString(generation))_$(intUtil.intToString(candidate)):$(metric)$(unit)\r\n")
+      results.close()
+      
+      results = new File("./results/$(script)/results.csv", File.FILE_ACCESS_WRITE)
+      results.setPos(results.getSize())
+      results.write("$(metric),")
+      results.close()
+   }
+}
\ No newline at end of file
diff --git a/src/emergenetic/scripts/blank.script b/src/emergenetic/scripts/blank.script
new file mode 100644
index 0000000..e69de29
diff --git a/src/helloworld/LICENSE.md b/src/helloworld/LICENSE.md
new file mode 100644
index 0000000..2a99aee
--- /dev/null
+++ b/src/helloworld/LICENSE.md
@@ -0,0 +1,675 @@
+### GNU GENERAL PUBLIC LICENSE
+
+Version 3, 29 June 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc.
+<http://fsf.org/>
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+### Preamble
+
+The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom
+to share and change all versions of a program--to make sure it remains
+free software for all its users. We, the Free Software Foundation, use
+the GNU General Public License for most of our software; it applies
+also to any other work released this way by its authors. You can apply
+it to your programs, too.
+
+When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights. Therefore, you
+have certain responsibilities if you distribute copies of the
+software, or if you modify it: responsibilities to respect the freedom
+of others.
+
+For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received. You must make sure that they, too, receive
+or can get the source code. And you must show them these terms so they
+know their rights.
+
+Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software. For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the
+manufacturer can do so. This is fundamentally incompatible with the
+aim of protecting users' freedom to change the software. The
+systematic pattern of such abuse occurs in the area of products for
+individuals to use, which is precisely where it is most unacceptable.
+Therefore, we have designed this version of the GPL to prohibit the
+practice for those products. If such problems arise substantially in
+other domains, we stand ready to extend this provision to those
+domains in future versions of the GPL, as needed to protect the
+freedom of users.
+
+Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish
+to avoid the special danger that patents applied to a free program
+could make it effectively proprietary. To prevent this, the GPL
+assures that patents cannot be used to render the program non-free.
+
+The precise terms and conditions for copying, distribution and
+modification follow.
+
+### TERMS AND CONDITIONS
+
+#### 0. Definitions.
+
+"This License" refers to version 3 of the GNU General Public License.
+
+"Copyright" also means copyright-like laws that apply to other kinds
+of works, such as semiconductor masks.
+
+"The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of
+an exact copy. The resulting work is called a "modified version" of
+the earlier work or a work "based on" the earlier work.
+
+A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user
+through a computer network, with no transfer of a copy, is not
+conveying.
+
+An interactive user interface displays "Appropriate Legal Notices" to
+the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+#### 1. Source Code.
+
+The "source code" for a work means the preferred form of the work for
+making modifications to it. "Object code" means any non-source form of
+a work.
+
+A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+The Corresponding Source need not include anything that users can
+regenerate automatically from other parts of the Corresponding Source.
+
+The Corresponding Source for a work in source code form is that same
+work.
+
+#### 2. Basic Permissions.
+
+All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+You may make, run and propagate covered works that you do not convey,
+without conditions so long as your license otherwise remains in force.
+You may convey covered works to others for the sole purpose of having
+them make modifications exclusively for you, or provide you with
+facilities for running those works, provided that you comply with the
+terms of this License in conveying all material for which you do not
+control copyright. Those thus making or running the covered works for
+you must do so exclusively on your behalf, under your direction and
+control, on terms that prohibit them from making any copies of your
+copyrighted material outside their relationship with you.
+
+Conveying under any other circumstances is permitted solely under the
+conditions stated below. Sublicensing is not allowed; section 10 makes
+it unnecessary.
+
+#### 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such
+circumvention is effected by exercising rights under this License with
+respect to the covered work, and you disclaim any intention to limit
+operation or modification of the work as a means of enforcing, against
+the work's users, your or third parties' legal rights to forbid
+circumvention of technological measures.
+
+#### 4. Conveying Verbatim Copies.
+
+You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+#### 5. Conveying Modified Source Versions.
+
+You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these
+conditions:
+
+-   a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+-   b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under
+    section 7. This requirement modifies the requirement in section 4
+    to "keep intact all notices".
+-   c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy. This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged. This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+-   d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+#### 6. Conveying Non-Source Forms.
+
+You may convey a covered work in object code form under the terms of
+sections 4 and 5, provided that you also convey the machine-readable
+Corresponding Source under the terms of this License, in one of these
+ways:
+
+-   a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+-   b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the Corresponding
+    Source from a network server at no charge.
+-   c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source. This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+-   d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge. You need not require recipients to copy the
+    Corresponding Source along with the object code. If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source. Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+-   e) Convey the object code using peer-to-peer transmission,
+    provided you inform other peers where the object code and
+    Corresponding Source of the work are being offered to the general
+    public at no charge under subsection 6d.
+
+A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal,
+family, or household purposes, or (2) anything designed or sold for
+incorporation into a dwelling. In determining whether a product is a
+consumer product, doubtful cases shall be resolved in favor of
+coverage. For a particular product received by a particular user,
+"normally used" refers to a typical or common use of that class of
+product, regardless of the status of the particular user or of the way
+in which the particular user actually uses, or expects or is expected
+to use, the product. A product is a consumer product regardless of
+whether the product has substantial commercial, industrial or
+non-consumer uses, unless such uses represent the only significant
+mode of use of the product.
+
+"Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to
+install and execute modified versions of a covered work in that User
+Product from a modified version of its Corresponding Source. The
+information must suffice to ensure that the continued functioning of
+the modified object code is in no case prevented or interfered with
+solely because modification has been made.
+
+If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or
+updates for a work that has been modified or installed by the
+recipient, or for the User Product in which it has been modified or
+installed. Access to a network may be denied when the modification
+itself materially and adversely affects the operation of the network
+or violates the rules and protocols for communication across the
+network.
+
+Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+#### 7. Additional Terms.
+
+"Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders
+of that material) supplement the terms of this License with terms:
+
+-   a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+-   b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+-   c) Prohibiting misrepresentation of the origin of that material,
+    or requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+-   d) Limiting the use for publicity purposes of names of licensors
+    or authors of the material; or
+-   e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+-   f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions
+    of it) with contractual assumptions of liability to the recipient,
+    for any liability that these contractual assumptions directly
+    impose on those licensors and authors.
+
+All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions; the
+above requirements apply either way.
+
+#### 8. Termination.
+
+You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+However, if you cease all violation of this License, then your license
+from a particular copyright holder is reinstated (a) provisionally,
+unless and until the copyright holder explicitly and finally
+terminates your license, and (b) permanently, if the copyright holder
+fails to notify you of the violation by some reasonable means prior to
+60 days after the cessation.
+
+Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+#### 9. Acceptance Not Required for Having Copies.
+
+You are not required to accept this License in order to receive or run
+a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+#### 10. Automatic Licensing of Downstream Recipients.
+
+Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+#### 11. Patents.
+
+A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+A contributor's "essential patent claims" are all patent claims owned
+or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+A patent license is "discriminatory" if it does not include within the
+scope of its coverage, prohibits the exercise of, or is conditioned on
+the non-exercise of one or more of the rights that are specifically
+granted under this License. You may not convey a covered work if you
+are a party to an arrangement with a third party that is in the
+business of distributing software, under which you make payment to the
+third party based on the extent of your activity of conveying the
+work, and under which the third party grants, to any of the parties
+who would receive the covered work from you, a discriminatory patent
+license (a) in connection with copies of the covered work conveyed by
+you (or copies made from those copies), or (b) primarily for and in
+connection with specific products or compilations that contain the
+covered work, unless you entered into that arrangement, or that patent
+license was granted, prior to 28 March 2007.
+
+Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+#### 12. No Surrender of Others' Freedom.
+
+If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under
+this License and any other pertinent obligations, then as a
+consequence you may not convey it at all. For example, if you agree to
+terms that obligate you to collect a royalty for further conveying
+from those to whom you convey the Program, the only way you could
+satisfy both those terms and this License would be to refrain entirely
+from conveying the Program.
+
+#### 13. Use with the GNU Affero General Public License.
+
+Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+#### 14. Revised Versions of this License.
+
+The Free Software Foundation may publish revised and/or new versions
+of the GNU General Public License from time to time. Such new versions
+will be similar in spirit to the present version, but may differ in
+detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies that a certain numbered version of the GNU General Public
+License "or any later version" applies to it, you have the option of
+following the terms and conditions either of that numbered version or
+of any later version published by the Free Software Foundation. If the
+Program does not specify a version number of the GNU General Public
+License, you may choose any version ever published by the Free
+Software Foundation.
+
+If the Program specifies that a proxy can decide which future versions
+of the GNU General Public License can be used, that proxy's public
+statement of acceptance of a version permanently authorizes you to
+choose that version for the Program.
+
+Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+#### 15. Disclaimer of Warranty.
+
+THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT
+WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND
+PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
+DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
+CORRECTION.
+
+#### 16. Limitation of Liability.
+
+IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR
+CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
+ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT
+NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR
+LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM
+TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER
+PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+#### 17. Interpretation of Sections 15 and 16.
+
+If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+END OF TERMS AND CONDITIONS
+
+### How to Apply These Terms to Your New Programs
+
+If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these
+terms.
+
+To do so, attach the following notices to the program. It is safest to
+attach them to the start of each source file to most effectively state
+the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+        <one line to give the program's name and a brief idea of what it does.>
+        Copyright (C) <year>  <name of author>
+
+        This program 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/>.
+
+Also add information on how to contact you by electronic and paper
+mail.
+
+If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+        <program>  Copyright (C) <year>  <name of author>
+        This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+        This is free software, and you are welcome to redistribute it
+        under certain conditions; type `show c' for details.
+
+The hypothetical commands \`show w' and \`show c' should show the
+appropriate parts of the General Public License. Of course, your
+program's commands might be different; for a GUI interface, you would
+use an "about box".
+
+You should also get your employer (if you work as a programmer) or
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. For more information on this, and how to apply and follow
+the GNU GPL, see <http://www.gnu.org/licenses/>.
+
+The GNU General Public License does not permit incorporating your
+program into proprietary programs. If your program is a subroutine
+library, you may consider it more useful to permit linking proprietary
+applications with the library. If this is what you want to do, use the
+GNU Lesser General Public License instead of this License. But first,
+please read <http://www.gnu.org/philosophy/why-not-lgpl.html>.
\ No newline at end of file
diff --git a/src/helloworld/README.md b/src/helloworld/README.md
new file mode 100644
index 0000000..154d5ab
--- /dev/null
+++ b/src/helloworld/README.md
@@ -0,0 +1,32 @@
+# HelloWorld 1.0         
+
+## License
+
+This EmerGen(e)tic module is copyright © 2017 Ben Goldsworthy (rumperuu).
+                                                                          
+HelloWorld 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.                                        
+                                                                           
+HelloWorld 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 HelloWorld.  If not, see <http://www.gnu.org/licenses/>.                             
+
+## Contact
+
+Email: me@bengoldsworthy.uk
+
+## Description
+
+HelloWorld is an EmerGen(e)tic module for testing the EmerGen(e)tic
+framework works as expected.
+
+## Installation
+
+Copy everything in this directory into your EmerGen(e)tic directory. Then,
+run the Terminal command `chmod +x ./project/HelloWorld/setup.sh`.
diff --git a/src/helloworld/project/helloworld/mutator.py b/src/helloworld/project/helloworld/mutator.py
new file mode 100644
index 0000000..5125c96
--- /dev/null
+++ b/src/helloworld/project/helloworld/mutator.py
@@ -0,0 +1,94 @@
+#!/usr/bin/python
+
+'''
+                             HelloWorld 1.0                            
+                    Copyright (c) 2017 Ben Goldsworthy (rumps)                   
+                                                                               
+    HelloWorld is an EmerGen(e)tic module for testing the function of the
+	EmerGen(e)tic framework.
+                                                                            
+    This file is part of the HelloWorld EmerGen(e)tic module.
+	
+	HelloWorld 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.                                        
+																			   
+	HelloWorld 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 HelloWorld.  If not, see <http://www.gnu.org/licenses/>.     
+'''
+
+import fileinput
+import random
+import shutil
+import string
+import sys
+
+script = ""
+
+def mutate(chromosome):
+	"""Randomly replaces letters in the string."""
+	mutation = [random.choice(string.ascii_lowercase) if random.randrange(100) < 20 else x for x in "Hello world"]
+	return ''.join(mutation)
+
+def createInitialPop(candidates):
+	"""Creates the initial population for generation 0."""
+	for i in range(candidates):
+		cID = "0_"+str(i)
+		shutil.copyfile("./helloworld/helloworld.txt", "./helloworld/"+script+"/0/helloworld"+cID+".txt")
+		
+def readChromosomeFromFile(cID):
+	"""Reads the chromosome from a given `CacheHandler*.dn` file."""
+	with open("./helloworld/"+script+"/"+str(cID.partition("_")[0])+"/helloworld"+cID+".txt") as inFile:
+		return inFile.readline()
+			
+def writeChromosomeToFile(cID, chromosome):
+	"""Writes a given chromosome to a `CacheHandler*.dn` file."""
+	with open("./helloworld/"+script+"/"+str(cID.partition("_")[0])+"/helloworld"+cID+".txt", "w") as outFile:
+		outFile.write(chromosome)
+
+
+def main(args):
+	random.seed()
+	
+	tabLevel = ""
+	chromosome = []
+	generation = int(args[0])
+	candidates = int(args[1])
+	chromosomes = []
+	newChromosomes = []
+	global script
+	script = args[3]
+	
+	if generation == 0:
+		createInitialPop(candidates)
+	else:
+		# Gets all of the previous generation's chromosomes.
+		for i in range(candidates):
+			oldCID = str(generation - 1) + "_" + str(i)
+			chromosomes.append((readChromosomeFromFile(oldCID), oldCID))
+		
+		# Applies a 30% chance of changing the string.
+		for currCandidate, chromosome in enumerate(chromosomes):
+			newCID = str(generation) + "_" + str(currCandidate)
+			
+			if random.randrange(100) < 30:
+				newChromosome = [mutate(chromosome[0]), newCID]
+			else:
+				newChromosome = [chromosome[0], newCID]
+			print(newChromosome)
+			newChromosomes.append(newChromosome)
+	
+		# Writes this new population to `.txt` files.
+		for currCandidate, chromosome in enumerate(newChromosomes):
+			newCID = str(generation) + "_" + str(currCandidate)
+			writeChromosomeToFile(newCID, chromosome[0])
+	return 0
+	
+if __name__ == '__main__':
+	sys.exit(main(sys.argv[1:]))
diff --git a/src/helloworld/project/helloworld/setup.sh b/src/helloworld/project/helloworld/setup.sh
new file mode 100644
index 0000000..4e9819d
--- /dev/null
+++ b/src/helloworld/project/helloworld/setup.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+# Performs pre-run setup before a test run.
+
+GENS=$1
+SCRIPT=$2
+
+mkdir helloworld
+touch ./results/$2/results.csv
+echo "Hello world" > ./helloworld/helloworld.txt
+mkdir ./helloworld/$2
+for i in `seq 0 $1`; do
+	mkdir ./helloworld/$2/$i
+done