private Automata<String> computeValidAutomata(String rowState, String columnExperiment, Automata<String> guessedAutomata) {
		
		//if (columnExperiment.equals("-1") && rowState.length() == 1) continue;
		
		String stateSequence = rowState + columnExperiment;
		stateSequence = stateSequence.replaceAll("-1", "");
		
		if ( stateSequence.length() > 0 ) {
			
			String[] individualStates = Utils.split(stateSequence);
		
			// If the table tells us that the sequence acquired by combining the row and column
			// values should 
			if ( getValue(rowState, columnExperiment) == true ) {
				
				// System.out.println("Adding sequence " + stateSequence + " to FSM.");
				
				// If the sequence that SHOULD be accepted by automata (according to the table)
				// is not, then we need to add these transitions:
				if (!guessedAutomata.validSequence(individualStates)) {
					
					// Revert automata back to start state (just incase)
					guessedAutomata.backToStartState();	
					
					// Record first state
					int startState = guessedAutomata.getStartState();
				
					// Find at which point the input string which SHOULD be accepted is no longer
					// accounted for by the automata
					for (int i = 0; i < individualStates.length - 1; i++) {
						
						// Is where I am now, plus the next state from the string in the FSA?
						// If not, we need to break and something needs to be added
						if (!guessedAutomata.transitionFilled(guessedAutomata.getCurrentState(), individualStates[i])) { 
							
							//System.out.println("Transition not filled " + guessedAutomata.getCurrentState() + " --> " + individualStates[i]);
							
							// ~MDC Needs work - how to determine which state to link to next: A new one? An existing one?
							// This is very crude, and very unlikely to be generalisable to a number of FSA.
							
							// If we have additional states to go to, go to them
							if (!guessedAutomata.atMaxStates()) {
							
								guessedAutomata.transition(guessedAutomata.getCurrentState(), individualStates[i], guessedAutomata.incrementStates());
							
							// If we have used up our alloted states, means we must go back. 
							} else {
								
								//System.out.println("Cannot create another state, so must go back.");
								
								int currentState = guessedAutomata.getCurrentState();
								
								// Try various paths to return to accepting state
								
								// Try all possible next states (bar starting state which is 1)
								// Backwards, why not.
								for (int j = guessedAutomata.getMaxStates(); j > 1; j--) {
									
									// Transition to this state
									guessedAutomata.setCurrentState(j);
									
									// Then try the remainder of the sequence to see if we return to the start
									// ~MDC Heavy assumption that the remainder of the path is filled!
									for (int k = i + 1; k < individualStates.length; k++) {
										
										guessedAutomata.transist(individualStates[k]);
										
									}
									
									// If we're back to an accepting state...
									if (guessedAutomata.inAcceptingState()) {
										
										//...add the initial step to the automata
										guessedAutomata.transition(currentState, individualStates[i], j);
										break;
									}
									
								}
								
								guessedAutomata.setCurrentState(currentState);
								
							}
							
						}
						
						// If it is, advance our current state by advancing the automata
						guessedAutomata.transist(individualStates[i]);
						
					}
					
					// Whatever happens, the LAST state in our string must take us back to the 
					// start state, as it is valid
					guessedAutomata.transition(guessedAutomata.getCurrentState(), individualStates[individualStates.length - 1], startState);
					
					//System.out.println(guessedAutomata);
					
				} else {
					
					//System.out.println("Sequence " + stateSequence + " already accounted for by FSM.");
					
				}
				
			} 
			
		}
		
		return guessedAutomata;
		
	}