diff --git a/fuzzer/Fuzzer.java b/fuzzer/Fuzzer.java
index fed23b73d44e28392272da730080b47d2f84cc16..6ec2b1613070d1b9f1484cbb608376081172445f 100644
--- a/fuzzer/Fuzzer.java
+++ b/fuzzer/Fuzzer.java
@@ -26,7 +26,7 @@ public class Fuzzer {
     private static final int INSTRUCTION_MIN = 0;
     private static final int INSTRUCTION_MAX = 1000;
     // Maximum variable name length
-    private static final int VAR_NAME_LENGTH_MAX = 100;
+    private static final int VAR_NAME_LENGTH_MAX = 1000;
     private static final int VAR_ASCII_MIN = 33;
     private static final int VAR_ASCII_MAX = 127;
     // Variable range
@@ -113,19 +113,22 @@ public class Fuzzer {
         switch (runCount){
             case 0:
                 // Test with stack full
-                return generateInput(true, INSTRUCTION_MAX, MAX_STACK_SIZE, false);
+                return generateInput(true, INSTRUCTION_MAX, MAX_STACK_SIZE, false, false);
             case 1:
                 // Test with stack full
-                return generateInput(true, INSTRUCTION_MAX, MAX_STACK_SIZE - 1, false);
+                return generateInput(true, INSTRUCTION_MAX, MAX_STACK_SIZE - 1, false, false);
             case 3:
                 // Run static tests and empty stack
-                return getStaticTests() + generateInput(true, INSTRUCTION_MAX, 0, false);
+                return getStaticTests() + generateInput(true, INSTRUCTION_MAX, 0, false, false);
             case 4:
                 // Test with dynamic probability
-                return generateInput(true, INSTRUCTION_MAX, 0, true);
+                return generateInput(true, INSTRUCTION_MAX, 0, true, false);
+            case 5:
+                // Test with long var names
+                return generateInput(true, INSTRUCTION_MAX, 0, true, true);
         }
         // Run from random stack
-        return generateInput(true, INSTRUCTION_MAX, 0, false);
+        return generateInput(true, INSTRUCTION_MAX, 0, false, false);
     }
 
     /*
@@ -157,7 +160,7 @@ public class Fuzzer {
             boolean stackFull = rand.nextInt(100) < STACK_FULL_PERCENTAGE;
 
             result.append(generateInput(false,
-                                        INSTRUCTION_MAX, MAX_STACK_SIZE, false));
+                                        INSTRUCTION_MAX, MAX_STACK_SIZE, false, false));
             // Increment generated
             generated += 1;
         }
@@ -171,14 +174,14 @@ public class Fuzzer {
      * @param numInstructions for the line
      * @return the concatenated input for the program as a string
      */
-    private static String generateInput(boolean correct, long numInstructions, int stackPreload, boolean dynamicProb){
+    private static String generateInput(boolean correct, long numInstructions, int stackPreload, boolean dynamicProb, boolean longVarNames){
         int stackSize = 0;
         int counter = 0;
 
         StringBuilder result = new StringBuilder();
 
         for ( int i = 0 ; i < stackPreload ; i++ ) {
-            result.append(completeInstruction(true, Instruction.PUSH));
+            result.append(completeInstruction(true, Instruction.PUSH, longVarNames));
             stackSize++;
         }
 
@@ -186,7 +189,7 @@ public class Fuzzer {
             while (counter < numInstructions) {
                 Instruction newInstr = Instruction.getRandomInstruction(stackSize, addProb);
                 stackSize = stackSize + newInstr.getStackChange();
-                result.append(completeInstruction(true, newInstr));
+                result.append(completeInstruction(true, newInstr, longVarNames));
                 if (dynamicProb) {
                     addCountProb(newInstr);
                 }
@@ -197,13 +200,13 @@ public class Fuzzer {
                 Instruction newInstr;
                 if (rand.nextInt(100) < LINE_ERROR_PERCENTAGE){
                     newInstr = Instruction.getRandomInstruction(2, addProb);
-                    result.append(completeInstruction(false, newInstr));
+                    result.append(completeInstruction(false, newInstr, longVarNames));
                     if (dynamicProb) {
                         addCountProb(newInstr);
                     }
                 } else {
                     newInstr = Instruction.getRandomInstruction(stackSize, addProb);
-                    result.append(completeInstruction(true, newInstr));
+                    result.append(completeInstruction(true, newInstr, longVarNames));
                     if (dynamicProb) {
                         addCountProb(newInstr);
                     }
@@ -226,7 +229,7 @@ public class Fuzzer {
      * @param instruction type
      * @return string with parameter
      */
-    private static String completeInstruction(boolean correct, Instruction instruction){
+    private static String completeInstruction(boolean correct, Instruction instruction, boolean longVarNames){
         
         String name = "";
         switch (instruction) {
@@ -243,7 +246,7 @@ public class Fuzzer {
             case REM:
                 // If not correct, make up a name not in the list
                 if (!correct){
-                    name = generateName();
+                    name = generateName(longVarNames);
                 }
                 // If no variables, return empty string
                 else if (vars.size() == 0){
@@ -260,7 +263,7 @@ public class Fuzzer {
                 // If not correct, make up a name not in the list
                 if (correct || vars.size() == 0){
                     // Make up a name
-                    name = generateName();
+                    name = generateName(longVarNames);
                     vars.add(name);
                 }
                 // If no variables, return empty string
@@ -272,7 +275,7 @@ public class Fuzzer {
                 name = " " + name;
                 break;
             case SAVE:
-                name = " " + generateName() + ".txt";
+                name = " " + generateName(longVarNames) + ".txt";
                 break;
             case PLUS:
             case SUB:
@@ -292,11 +295,17 @@ public class Fuzzer {
      *
      * @return the name generated
      */
-    private static String generateName(){
+    private static String generateName(boolean longVarName){
         StringBuilder name = new StringBuilder();
         int counter = 0;
-        // Randomise the length of the string
-        int length = rand.nextInt(VAR_NAME_LENGTH_MAX);
+        int length;
+
+        if (longVarName){
+            length = VAR_NAME_LENGTH_MAX + 100;
+        } else {
+            // Randomise the length of the string
+            length = rand.nextInt(VAR_NAME_LENGTH_MAX);
+        }
 
         // Add random bounded characters to string
         while (counter < length){