add spring boot and gradle.

src/main/java/com/matthewjensen/project/ProjectApplication.java

@@ -0,0 +1,33 @@
+package com.matthewjensen.project;
+
+import com.matthewjensen.project.modules.AnagramMain;
+import java.io.FileNotFoundException;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+@SpringBootApplication
+public class ProjectApplication {
+
+	public static void main(String[] args) {
+		SpringApplication.run(ProjectApplication.class, args);
+	}
+
+}
+@RestController
+class TwentyQuestions {
+
+    @RequestMapping("/20questions")
+    String index() {
+        //AnagramMain anagram = new AnagramMain();
+        
+        //String[] args = new String[4];
+        //try {
+        //    anagram.main(args);
+        //} catch (FileNotFoundException e){
+        //}
+        return "Hello There";
+    }
+}

src/main/java/com/matthewjensen/project/modules/20-questions/QuestionMain.java

@@ -0,0 +1,119 @@
+package com.matthewjensen.project.modules;
+
+// CSE 145 Lab 6: 20 Questions
+//
+// To use the jGRASP debugger with this program, set a breakpoint
+// and once the execution breaks, open 'this' or 'tq' on the left,
+// then look at its variable 'tree'.  That's your QuestionTree.
+// Drag your 'tree' over to the right to see a visualization of it.
+// 
+// (Your QuestionTree is constructed by this file on line 30.
+// The overall loop to play games is around line 68.)
+
+import java.io.*;
+import java.util.Scanner;
+
+/** A basic text user interface for the 20 questions game. */
+public class QuestionMain implements UserInterface {
+    public static void main(String[] args) {
+        QuestionMain tq = new QuestionMain();
+        tq.run();
+    }
+    
+    
+    // fields
+    private Scanner console;
+    private QuestionTree tree;
+    
+    /** Constructs a text user interface and its question tree. */
+    public QuestionMain() {
+        console = new Scanner(System.in);
+        tree = new QuestionTree(this);
+    }
+    
+    /**
+     * Returns the user's response as a String.
+     */
+    public String nextLine() {
+        return console.nextLine();
+    }
+
+    /** Prints the given string to the console. */
+    public void print(String message) {
+        System.out.print(message);
+        System.out.print(" ");
+    }
+
+    /** Prints the given string to the console. */
+    public void println(String message) {
+        System.out.println(message);
+    }
+
+    /** Prints a blank line to the console. */
+    public void println() {
+        System.out.println();
+    }
+
+    /**
+     * Waits for the user to answer a yes/no question on the console and returns the
+     * user's response as a boolean (true for anything that starts with "y" or "Y").
+     */
+    public boolean nextBoolean() {
+        String answer = console.nextLine();
+        return answer.trim().toLowerCase().startsWith("y");
+    }
+    
+    // private helper for overall game(s) loop
+    private void run() {
+        println("Welcome to the game of 20 Questions!");
+        load();
+        
+        // "Think of an item, and I will guess it in N tries."
+        println("\n" + BANNER_MESSAGE);
+            
+        do {
+            // play one complete game
+            println();      // blank line between games
+            tree.play();
+            print(PLAY_AGAIN_MESSAGE);
+        } while (nextBoolean());   // prompt to play again
+        
+        // print overall stats
+        // Games played: N ...  I have won: M
+        println("\n" + String.format(STATUS_MESSAGE,
+                tree.totalGames(), tree.gamesWon()));
+
+        save();
+    }
+    
+    // common code for asking the user whether they want to save or load
+    private void load() {
+        print(LOAD_MESSAGE);
+        if (nextBoolean()) {
+            print(SAVE_LOAD_FILENAME_MESSAGE);
+            String filename = nextLine();
+            try {
+                Scanner in = new Scanner(new File(filename));
+                tree.load(in);
+            } catch (FileNotFoundException e) {
+                System.out.println("Error: " + e.getMessage());
+            }
+        }
+    }
+    
+    // common code for asking the user whether they want to save or load
+    private void save() {
+        print(SAVE_MESSAGE);
+        if (nextBoolean()) {
+            print(SAVE_LOAD_FILENAME_MESSAGE);
+            String filename = nextLine();
+            try {
+                PrintStream out = new PrintStream(new File(filename));
+                tree.save(out);
+                out.close();
+            } catch (FileNotFoundException e) {
+                System.out.println("Error: " + e.getMessage());
+            }
+        }
+    }
+}

src/main/java/com/matthewjensen/project/modules/20-questions/QuestionNode.java

@@ -0,0 +1,89 @@
+package com.matthewjensen.project.modules;
+/**
+*
+* Matt Jensen
+* CS145 - Lab 6
+* 5/30/19
+*
+*/
+
+public class QuestionNode {
+    private QuestionNode yes;
+    private QuestionNode no;
+    private String data;
+    private boolean isQuestion;
+    
+
+    public QuestionNode(String input) {
+        this.data = unwrap(input);
+    }
+    public QuestionNode(String input, boolean isQuestion) {
+        this.data = unwrap(input);
+        if( isQuestion ) {
+            this.markAsQuestion();
+        } else {
+            this.markAsAnswer();
+        }
+    }
+    public boolean hasQuestion() {
+        return ! this.isAnswer() && (this.hasYes() || this.hasNo() );
+    }
+    public boolean needsAnswer() {
+        return ! this.isAnswer() && (! this.hasYes() || ! this.hasNo() );
+    }
+    public void markAsQuestion() {
+        this.isQuestion = true;
+    }
+    public void markAsAnswer() {
+        this.isQuestion = false;
+    }
+    public void addYes(QuestionNode yes) {
+        this.yes = yes;
+    }
+    public void addNo(QuestionNode no) {
+        this.no = no;
+    }
+    public void addAnswer(QuestionNode answer) {
+        if( this.hasYes() ) {
+            this.addNo(answer);
+        } else {
+            this.addYes(answer);
+        }
+    }
+    public QuestionNode getYes() {
+        return this.yes;
+    }
+    public QuestionNode getNo() {
+        return this.no;
+    }
+    public String toString(boolean wrap) {
+        return this.wrap(this.data);
+    }
+    public String toString() {
+        return this.data;
+    }
+    public boolean isAnswer() {
+        return this.isQuestion == false;
+    }
+    public boolean hasYes() {
+        return this.yes != null;
+    }
+    public boolean hasNo() {
+        return this.no != null;
+    }
+    private String unwrap(String input) {
+        if( input.contains(":") ) {
+            return input.split(":")[1];
+        }
+        return input;
+    }
+    private String wrap(String input) {
+        String prefix = "";
+        if( this.isAnswer() ) {
+            prefix = "A";
+        } else {
+            prefix = "Q";
+        }
+        return prefix + ":" + input;
+    }
+}

src/main/java/com/matthewjensen/project/modules/20-questions/QuestionNodeTest.java

@@ -0,0 +1,15 @@
+package com.matthewjensen.project.modules;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertArrayEquals;
+import org.junit.Test;
+import java.util.*;
+
+public class QuestionNodeTest {
+    @Test
+    public void exists() {
+        QuestionNode node = new QuestionNode("tail"); 
+        //assertEquals("tail", node.getQuestion());
+    }
+}

src/main/java/com/matthewjensen/project/modules/20-questions/QuestionTree.java

@@ -0,0 +1,200 @@
+package com.matthewjensen.project.modules;
+/**
+*
+* Matt Jensen
+* CS145 - Lab 6
+* 5/30/19
+*
+*/
+
+import java.io.*;
+import java.util.*;
+
+public class QuestionTree {
+    
+    private QuestionNode root;
+    private UserInterface ui;
+    private Stack<QuestionNode> unanswered;        
+    private int totalGames;
+    private int gamesWon;
+    private QuestionNode lastQuestion;
+
+    public QuestionTree(UserInterface ui) {
+        this.setUserInterface(ui);
+        this.setRoot(null);
+    }
+    public QuestionTree(UserInterface ui, QuestionNode root) {
+        this.setUserInterface(ui);
+        this.setRoot(root);
+    }
+
+    /**
+    *
+    * Public Methods.
+    *
+    */
+    public void replaceYes(QuestionNode newQuestion, QuestionNode parent) {
+        parent.addYes(newQuestion);
+    }
+
+    public void save(PrintStream output) {
+        this.print(output, this.getRoot());
+        //output.print("hello");
+    }
+    private void print(PrintStream output, QuestionNode current) {
+        if(current == null) {
+            return;
+        } else {
+            output.print(current.toString(true));
+            if(current.hasYes()){
+                output.println();
+                this.print(output, current.getYes());
+            } 
+            if(current.hasNo()){
+                output.println();
+                this.print(output, current.getNo());
+            } 
+        }
+        return;
+
+    }
+    public void play() {
+        this.lastQuestion = null;
+        if( this.getRoot() == null ) {
+            this.ui.print("First question?");
+            this.setRoot(new QuestionNode(this.ui.nextLine(), true));
+            this.ui.print("If yes?");
+            this.getRoot().addYes(new QuestionNode(this.ui.nextLine()));
+            this.ui.print("If no?");
+            this.getRoot().addNo(new QuestionNode(this.ui.nextLine()));
+        }
+        QuestionNode guess = this.guess(this.getRoot());
+        this.ui.print("Would your object happen to be " + guess.toString() + "?");
+        boolean correctGuess = this.ui.nextBoolean();
+        if( correctGuess ) {
+            this.ui.println("I win!");
+            gamesWon++;
+        } else {
+            this.ui.print("I lose.");
+            this.addDistinction(guess);
+        }
+        totalGames++;
+    }
+    private QuestionNode getActual(QuestionNode guess) {
+        this.ui.print("What is your object?");
+        QuestionNode actual = new QuestionNode(this.ui.nextLine(), false);
+        return actual;
+    }   
+    private QuestionNode getNewQuestion(QuestionNode guess) {
+        this.ui.println("Type a yes/no question to distinguish your item from " + guess.toString() + ":");
+        QuestionNode newQuestion = new QuestionNode(this.ui.nextLine(), true);
+        return newQuestion;
+    }   
+    private boolean getReplaceYes(QuestionNode guess, QuestionNode newQuestion) {
+        this.ui.println("And what is the answer for " + newQuestion + "?");
+        boolean replaceYes = this.ui.nextBoolean();
+        return replaceYes;
+    }   
+    private void addDistinction(QuestionNode guess) {
+        QuestionNode actual = this.getActual(guess);
+        QuestionNode newQuestion = this.getNewQuestion(guess);
+        boolean replaceYes = this.getReplaceYes(guess, newQuestion);
+        if( replaceYes ) {
+            newQuestion.addYes(actual);
+            newQuestion.addNo(guess);
+        } else {
+            newQuestion.addNo(actual);
+            newQuestion.addYes(guess);
+        }
+        this.replaceYes(newQuestion, this.lastQuestion);
+    }
+    
+    private QuestionNode guess(QuestionNode current) {
+        if( current == null || current.isAnswer() ) {
+            return current;
+        } else {
+            this.ui.print(current.toString());
+            this.lastQuestion = current;
+            if( this.ui.nextBoolean() ) {
+                return this.guess(current.getYes());
+            } else {
+                return this.guess(current.getNo());
+            }
+        }
+    }
+    public int totalGames() {
+        return this.totalGames;
+    }
+    public int gamesWon() {
+        return this.gamesWon;
+    }
+    public QuestionNode getRoot() {
+        return this.root;
+    }
+
+    /**
+    *
+    * Private Methods.
+    *
+    */
+
+    private void setRoot(QuestionNode root) {
+        this.root = root;
+    }
+
+    // pre: ui not null
+    private void setUserInterface(UserInterface ui) {
+        if( ui == null) {
+            throw new IllegalArgumentException();
+        }
+        this.ui = ui;
+    }
+
+    // pre: coming from a file.
+    private boolean containsQuestion(String line) {
+        return line.charAt(0) == 'Q';
+    }
+
+    public void load(Scanner input) {
+        // base case
+        if( ! input.hasNextLine() ) {
+            return;
+        }
+        Stack<QuestionNode> remaining = new Stack<QuestionNode>();
+        this.build(input, remaining);
+        return;
+    }
+    private void build(Stack<QuestionNode> remaining, QuestionNode root) {
+
+    }
+    private void build(Scanner input, Stack<QuestionNode> remaining) {
+        // base case
+        if( ! input.hasNextLine() ) {
+            if( ! remaining.empty() ) {
+                throw new IllegalArgumentException("question unanswered");
+            }
+            return;
+        } else {
+            String line = input.nextLine();
+            QuestionNode current = new QuestionNode(line, containsQuestion(line));
+            if( remaining.empty() ) {
+                if( this.getRoot() == null ) {
+                    this.setRoot(current);
+                } else {
+                    throw new IllegalArgumentException("bad root element");
+                }
+            } else {
+                QuestionNode last = remaining.pop();
+                last.addAnswer(current);
+                if(last.needsAnswer() ) {
+                    remaining.add(last);
+                }
+            }
+            if( ! current.isAnswer() ) {
+                remaining.add(current);
+            }
+            this.build(input, remaining);
+        }
+        return;
+    }
+}

src/main/java/com/matthewjensen/project/modules/20-questions/QuestionTreeTest.java

@@ -0,0 +1,78 @@
+package com.matthewjensen.project.modules;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertArrayEquals;
+import org.junit.Test;
+import java.util.*;
+import java.io.*;
+
+public class QuestionTreeTest {
+    @Test
+    public void testExistance() {
+        UserInterface ui = new QuestionMain();
+        QuestionTree tree = new QuestionTree(ui); 
+        assertTrue(true);
+    }
+
+    @Test
+    public void load() {
+        UserInterface ui = new QuestionMain();
+        QuestionTree tree = new QuestionTree(ui); 
+        String file = "Q:Is it an animal?\nA:cat\nQ:Does it go on your feet?\nA:shoe\nA:computer";
+        tree.load(new Scanner(file));
+        assertEquals("Is it an animal?", tree.getRoot().toString());
+    }
+
+    @Test
+    public void replace() {
+        UserInterface ui = new QuestionMain();
+        QuestionTree tree = new QuestionTree(ui); 
+        String file = "Q:Is it an animal?\nA:cat\nA:table?";
+        tree.load(new Scanner(file));
+        QuestionNode newQuestion = new QuestionNode("Is it black?", true);
+        tree.replaceYes(newQuestion, tree.getRoot());
+        assertEquals("Is it black?", tree.getRoot().getYes().toString());
+    }
+
+    @Test
+    public void otherload() throws FileNotFoundException {
+        UserInterface ui = new QuestionMain();
+        QuestionTree tree = new QuestionTree(ui); 
+        tree.load(new Scanner(new File("question2.txt")));
+        assertEquals("Is it an animal?", tree.getRoot().toString());
+    }
+    @Test
+    public void save() throws FileNotFoundException, IOException {
+        // setup
+        UserInterface ui = new QuestionMain();
+        QuestionTree tree = new QuestionTree(ui); 
+        ByteArrayOutputStream result = new ByteArrayOutputStream();
+        tree.load(new Scanner(new File("question1.txt")));
+        PrintStream out = new PrintStream(result);
+        tree.save(out);
+        String expected = "Q:Is it an animal?\nA:cat\nQ:Does it go on your feet?\nA:shoe\nA:computer";
+        assertEquals(expected, result.toString());
+        result.close();
+    }
+    @Test
+    public void saveLonger() throws FileNotFoundException, IOException {
+        // setup
+        UserInterface ui = new QuestionMain();
+        QuestionTree tree = new QuestionTree(ui); 
+        ByteArrayOutputStream result = new ByteArrayOutputStream();
+        tree.load(new Scanner(new File("question2.txt")));
+        PrintStream out = new PrintStream(result);
+        tree.save(out);
+        String expected = "Q:Is it an animal?\nQ:Can it fly?\nA:bird\nQ:Does it have a tail?\nA:mouse\nA:spider\nQ:Does it have wheels?\nA:bicycle\nQ:Is it nice?\nA:TA\nA:teacher";
+        assertEquals(expected, result.toString());
+        result.close();
+    }
+    public void play() throws FileNotFoundException, IOException {
+        // setup
+        UserInterface ui = new QuestionMain();
+        QuestionTree tree = new QuestionTree(ui); 
+        tree.load(new Scanner(new File("question2.txt")));
+        ByteArrayOutputStream result = new ByteArrayOutputStream();
+    }
+}

src/main/java/com/matthewjensen/project/modules/20-questions/UserInterface.java

@@ -0,0 +1,46 @@
+package com.matthewjensen.project.modules;
+// CSE 145 Lab 6: 20 Questions
+
+/**
+ * Interface describing abstract user interaction operations.
+ * This interface is implemented by the graphical and text UIs for the game.
+ * Your QuestionTree interacts with the UI through this interface.
+ * @author Marty Stepp
+ * @version 2010/02/20
+ */
+public interface UserInterface {
+    /**
+     * Waits for the user to input a yes/no answer (by typing, clicking, etc.),
+     * and returns that answer as a boolean value.
+     * @return the answer typed by the user as a boolean (yes is true, no is false)
+     */
+    boolean nextBoolean();
+
+    /**
+     * Waits for the user to input a text value, and returns that answer as a String.
+     * @return the answer typed by the user as a String (empty string if no answer typed)
+     */
+    String nextLine();
+    
+    /**
+     * Displays the given output message to the user.
+     * @param message The message to display.  Assumes not null.
+     */
+    void print(String message);
+    
+    /**
+     * Displays the given output message to the user.
+     * If the UI is a text UI, also inserts a line break (\n).
+     * @param message The message to display.  Assumes not null.
+     */
+    void println(String message);
+
+    // various messages that are output by the user interface
+    // (your QuestionTree does not need to refer to these messages)
+    final String PLAY_AGAIN_MESSAGE = "Challenge me again?";
+    final String SAVE_MESSAGE = "Shall I remember these games?";
+    final String LOAD_MESSAGE = "Shall I recall our previous games?";
+    final String SAVE_LOAD_FILENAME_MESSAGE = "What is the file name?";
+    final String STATUS_MESSAGE = "Games played: %d\nI won: %d";
+    final String BANNER_MESSAGE = "Think of an item, and I will guess it.";
+}

src/main/java/com/matthewjensen/project/modules/20-questions/expected_output_1.txt

@@ -0,0 +1,27 @@
+Welcome to the game of 20 Questions!
+Shall I recall our previous games? No
+
+Think of an item, and I will guess it.
+
+Would your object happen to be computer? N
+I lose. What is your object? cat
+Type a yes/no question to distinguish your item from computer: Is it an animal?
+And what is the answer for your object? Yes
+Challenge me again? y
+
+Is it an animal? y
+Would your object happen to be cat? NO
+I lose. What is your object? Dog
+Type a yes/no question to distinguish your item from cat: Does it meow?
+And what is the answer for your object? no
+Challenge me again? y
+
+Is it an animal? yes
+Does it meow? No
+Would your object happen to be Dog? YES
+I win!
+Challenge me again? nope
+
+Games played: 3
+I won: 1
+Shall I remember these games? no

src/main/java/com/matthewjensen/project/modules/20-questions/expected_output_2.txt

@@ -0,0 +1,23 @@
+Welcome to the game of 20 Questions!
+Shall I recall our previous games? yes please
+What is the file name? question2.txt
+
+Think of an item, and I will guess it.
+
+Is it an animal? no
+Does it have wheels? nope
+Is it nice? nah
+Would your object happen to be teacher? yes
+I win!
+Challenge me again? y
+
+Is it an animal? yes
+Can it fly? YES
+Would your object happen to be bird? yep
+I win!
+Challenge me again? n
+
+Games played: 2
+I won: 2
+Shall I remember these games? y
+What is the file name? out.txt

src/main/java/com/matthewjensen/project/modules/20-questions/question1.txt

@@ -0,0 +1,5 @@
+Q:Is it an animal?
+A:cat
+Q:Does it go on your feet?
+A:shoe
+A:computer

src/main/java/com/matthewjensen/project/modules/20-questions/question2.txt

@@ -0,0 +1,11 @@
+Q:Is it an animal?
+Q:Can it fly?
+A:bird
+Q:Does it have a tail?
+A:mouse
+A:spider
+Q:Does it have wheels?
+A:bicycle
+Q:Is it nice?
+A:TA
+A:teacher

src/main/java/com/matthewjensen/project/modules/anagrams/AnagramMain.java

@@ -0,0 +1,99 @@
+package com.matthewjensen.project.modules;
+
+/**
+CSE 143, Winter 2010, Marty Stepp
+Homework 6 (Anagrams)
+
+AnagramMain is a client program that prompts a user for the name of a
+dictionary file and then gives the user the opportunity to find anagrams of
+various phrases.  It constructs an Anagrams object to do the actual
+search for anagrams that match the user's phrases.
+
+@author Stuart Reges and Marty Stepp
+@version originally written by reges on 5/9/2005; modified by stepp on 2/6/2010
+*/
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Collections;
+import java.util.Scanner;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class AnagramMain {
+    // dictionary file to use for input (change to dict2, dict3)
+    private static final String DICTIONARY_FILE = "dict1.txt";
+    
+    // set to true to test runtime and # of letter inventories created
+    private static final boolean TIMING = true;
+    private static final boolean DEBUG = true;
+    
+    
+    public static void main(String[] args) throws FileNotFoundException {
+        System.out.println("Welcome to the CS 145 anagram solver.");
+        System.out.println("Using dictionary file " + DICTIONARY_FILE + ".");
+
+        // read dictionary into a set
+        Scanner input = new Scanner(new File(DICTIONARY_FILE));
+        Set<String> dictionary = new TreeSet<String>();
+        while (input.hasNextLine()) {
+            dictionary.add(input.nextLine());
+        }
+        dictionary = Collections.unmodifiableSet(dictionary);   // read-only
+
+        // create Anagrams object for, well, solving anagrams
+        Anagrams solver = new Anagrams(dictionary);
+
+        // get first phrase to solve
+        Scanner console = new Scanner(System.in);
+        String phrase = getPhrase(console);
+        
+        if (DEBUG) {
+            phrase = "barbara bush";
+        }
+        // loop to get/solve each phrase
+        while (phrase.length() > 0) {
+            System.out.println("All words found in \"" + phrase + "\":");
+            Set<String> allWords = solver.getWords(phrase);
+            System.out.println(allWords);
+            System.out.println();
+
+            System.out.print("Max words to include (Enter for no max)? ");
+            String line = console.nextLine().trim();
+            if (DEBUG) {
+                line = "4";
+            }
+            
+            long startTime = System.currentTimeMillis();
+            if (line.length() > 0) {
+                // use a max
+                int max = new Scanner(line).nextInt();
+                solver.print(phrase, max);   // print all anagrams of phrase
+            } else {
+                // no max
+                solver.print(phrase);        // print all anagrams of phrase
+            }
+            long endTime = System.currentTimeMillis();
+            System.out.println();
+            
+            // 12247 ms elapsed, 2594392 unique LetterInventory object(s) created
+            if (TIMING) {
+                long elapsed = endTime - startTime;
+                int inventories = LetterInventory.getInstanceCount();
+                System.out.println(elapsed + " ms elapsed, " + inventories + 
+                        " unique LetterInventory object(s) created");
+                LetterInventory.resetInstanceCount();
+            }
+
+            // get next phrase to solve
+            phrase = getPhrase(console);
+        }
+    }
+    
+    // Helper to prompt for a phrase to generate anagrams.
+    public static String getPhrase(Scanner console) {
+        System.out.println();
+        System.out.print("Phrase to scramble (Enter to quit)? ");
+        return console.nextLine().trim();
+    }
+}

src/main/java/com/matthewjensen/project/modules/anagrams/Anagrams.java

@@ -0,0 +1,149 @@
+package com.matthewjensen.project.modules;
+/**
+*
+* Matt Jensen
+* 5/28/19
+* CS 145
+* Assignment 3 - Anagrams
+* 
+* Finds and prints all anagrams for a specific phrase.
+* Uses recursive backtracking.
+* 
+*/
+
+import java.util.*;
+
+public class Anagrams {
+
+    private Set<String> dictionary;
+    private int max;
+    private String phrase;
+    private List<String> solution = new ArrayList<String>();
+    private Set<String[]> foundSolutions = new HashSet<String[]>();
+    private Map<String, LetterInventory> inventories = new HashMap<String, LetterInventory>();
+
+    public Anagrams(Set<String> dictionary){
+        this.setDictionary(dictionary);
+    }
+
+    // @returns	words	anagrams in dictionary made with the word
+    public Set<String> getWords(String phrase){
+        Set<String> anagrams = new TreeSet<String>();
+        if( ! this.inventories.keySet().contains(phrase) ) {
+            this.inventories.put(phrase, new LetterInventory(phrase));
+        }
+        LetterInventory inventory = this.getInventory(phrase);
+        for(String dictionaryWord : this.dictionary) {
+            if(inventory.contains(dictionaryWord)){
+                anagrams.add(dictionaryWord);
+            }
+        }
+        return anagrams;
+    }
+    // easier signature without max.
+    public void print(String phrase){
+        print(phrase, this.getWords(phrase).size());
+    }
+    // populates foundSolutions then prints each to console.
+    public void print(String phrase, int max){
+        this.setPhrase(phrase);
+        this.setMax(max);
+        this.findSolutions();
+        for(String[] solution : this.getSolutions() ) {
+            System.out.println(Arrays.toString(solution));
+        }
+    }
+
+    // private methods.
+    // called to populate foundSolutions.
+    private void findSolutions() {
+        this.foundSolutions = new HashSet<String[]>();
+        this.solution = new ArrayList<String>();
+        LetterInventory inventory = this.getInventory(this.getPhrase());
+        this.findSolutions(inventory);
+    }
+    
+    private void findSolutions(LetterInventory remainingInventory) {
+        // check if solution
+        if(remainingInventory.isEmpty()) {
+            this.addSolution();
+            return;
+        }
+        // guesses.
+        Set<String> values = this.getWords(phrase);
+        for( String value : values ) {
+            if( isValid(value, remainingInventory) ) {
+                applyValue(value, remainingInventory);
+                findSolutions(remainingInventory);
+                removeValue(value, remainingInventory);
+            }
+
+        }
+        return;
+    }
+
+    // tests is the value makes the decision tree dead end.
+    private boolean isValid(String value, LetterInventory inventory) {
+        if( ! inventory.contains(value)) {
+            return false;
+        }
+        return true;
+    }
+    // backtracks the apply value step.
+    private void removeValue(String value, LetterInventory inventory) {
+        inventory.add(value);
+        this.solution.remove(value);
+    }
+    // adds the value to solution currently being built.
+    private void applyValue(String value, LetterInventory inventory) {
+        inventory.subtract(value);
+        this.solution.add(value);
+    }
+
+    // methods for saving a found solution
+    private void addSolution() {
+        if( this.solution.size() > this.max) {
+            return;
+        }
+        int i = 0;
+        String[] newSolution = new String[this.solution.size()];
+        for(String word : this.solution) {
+            newSolution[i] = word;
+            i++;
+        }
+        this.foundSolutions.add(newSolution);
+    }
+
+    // setters and getters for class variables.
+    private Set<String[]> getSolutions() {
+        return this.foundSolutions;
+    }
+    private List<String> getSolution() {
+        return this.solution;
+    }
+    private LetterInventory getInventory(String phrase) {
+        return this.inventories.get(phrase);
+    }
+    private void setDictionary(Set<String> dictionary) {
+        this.dictionary = dictionary;
+    }
+    // sets the max or as the total number of found words in the phrase.
+    private void setMax(int max) {
+        if( max > 0 ) {
+        this.max = max;
+        }
+        else{
+            this.max = this.getWords(this.getPhrase()).size();
+        }
+    }
+    // errors if phrase is null or sets class phrase variable.
+    private void setPhrase(String phrase) {
+        if(phrase == null) {
+            throw new IllegalArgumentException();
+        }
+        this.phrase = phrase;
+    }
+    private String getPhrase() {
+        return this.phrase;
+    }
+}

src/main/java/com/matthewjensen/project/modules/anagrams/Helper.java

@@ -0,0 +1,54 @@
+package com.matthewjensen.project.modules;
+
+import java.util.*;
+
+public class Helper {
+    
+    public static boolean isSolution(int max, LetterInventory inventory, Set<String> foundWords) {
+        if( inventory.isEmpty() ) {
+            return true;
+        }
+        if( foundWords.size() >= max) {
+            return true;
+        }
+        return false;
+    }
+
+    public static void displaySolution(Set<String> foundWords) {
+        System.out.println(Arrays.toString(foundWords.toArray()));
+        return;
+    }
+
+    public static boolean isValid(int max, LetterInventory inventory, Set<String> foundWords, Set<String> remainingWords ) {
+        String next = "";
+        for( String found : foundWords ) {
+            next = found;
+        }
+        if(inventory.contains(next)) {
+            if( foundWords.size() <= max - 1 ) {
+                return true;
+            }
+        }
+        return false;
+    }
+    public static void applyValue(int max, LetterInventory inventory, Set<String> foundWords, Set<String> remainingWords ) {
+        String next = "";
+        for( String found : foundWords ) {
+            next = found;
+        }
+        inventory.subtract(next);
+        foundWords.add(next);
+        remainingWords.remove(next);
+        return;
+    }
+    public static void removeValue(int max, LetterInventory inventory, Set<String> foundWords, Set<String> remainingWords ) {
+        String next = "";
+        for( String found : foundWords ) {
+            next = found;
+        }
+        inventory.add(next);
+        foundWords.remove(next);
+        remainingWords.add(next);
+        return;
+    }
+}

src/main/java/com/matthewjensen/project/modules/anagrams/LetterInventory.java

@@ -0,0 +1,175 @@
+package com.matthewjensen.project.modules;
+
+/**
+*
+* Matt Jensen
+* CS145 - Lab 3
+* 5/30/19
+*
+* Add, subtract and manage inventories of letters.
+* Lower case, alphabetical inventories only.
+*
+*/
+
+import java.util.*;
+
+public class LetterInventory {
+    //todo
+    public boolean contains(String needle) {
+        return false;
+    }
+    //todo
+    public static int getInstanceCount() {
+        return 1;
+    }
+    public static int resetInstanceCount() {
+        return 1;
+    }
+
+    // stored the inventory and count.
+    private Map<Character, Integer> inventory;
+
+    // add phrase to inventory. 
+    // instantiated inventory to 0 for all letters.
+    public LetterInventory(String phrase) {
+        this.setInventory();
+        this.add(phrase);
+    }
+    
+    // empty constructor without default string. 
+    // For testing.
+    public LetterInventory() {
+        this.setInventory();
+    }
+
+    // adds characters of string from inventory.
+    public void add(String string) {
+        char character;
+        for(int i = 0; i < string.length(); i++) {
+            character = string.charAt(i);
+            this.add(character);
+        }
+    }
+
+    // adds characters from another inventory from inventory.
+    // returns copy of inventory.
+    public LetterInventory add(LetterInventory inventory) {
+        LetterInventory newInventory = new LetterInventory();
+        int count = 0;
+        for(Character character : this.getInventory().keySet() ) {
+            count = this.get(character) + inventory.get(character);
+            newInventory.set(character, count);
+        }
+        return newInventory;
+    }
+
+    // removes characters from another inventory from inventory.
+    // returns copy of inventory.
+    public LetterInventory subtract(LetterInventory inventory) {
+        LetterInventory newInventory = new LetterInventory();
+        for(Character character : this.getInventory().keySet() ) {
+            newInventory.set(character, this.get(character) - inventory.get(character));
+        }
+        return newInventory;
+    }
+    // removes characters of string from inventory.
+    public void subtract(String string) {
+        char character;
+        for(int i = 0; i < string.length(); i++) {
+            character = string.charAt(i);
+            this.subtract(character);
+        }
+    }
+
+    // count number of characters in inventory.
+    public int get(Character character) {
+        if( ! this.has(character) ) {
+            return 0;
+        }
+        return this.getInventory().get(Character.toLowerCase(character));
+    }
+
+    // set inventory count of character.
+    // converts upper to lower.
+    // ignores non-alphabetic characters.
+    public void set(Character character, int count) {
+        if( ! Character.isAlphabetic(character) ) {
+            return;
+        }
+        character = Character.toLowerCase(character);
+        if( ! this.has(character) ) {
+            throw new IllegalArgumentException("character not found" + character);
+        }
+        this.inventory.put(character, count);
+    }
+
+    // represents the inventory in string.
+    // one letter for each count in the inventory map.
+    public String toString() {
+        String string = "[";
+        for(char character : this.getInventory().keySet()) { 
+            int count = this.getInventory().get(character);
+            for(int i = 0; i < count; i++) {
+                string += character;
+            }
+        }
+        string += "]";
+        return string;
+    }
+
+    // counts all letters in inventory.
+    // duplicates counted as well.
+    public int size() {
+        int sum = 0;
+        for( Integer count : this.getInventory().values() ) {
+            sum += count;
+        }
+        return sum;
+    }
+
+    // tests whether inventory is empty.
+    public boolean isEmpty() {
+        return this.size() <= 0;
+    }
+
+    // setters and getters.
+
+    // instantiated inventory to 0 for all letters.
+    private void setInventory() {
+        this.inventory = new TreeMap<Character, Integer>();
+        for(int i = 0; i <= 25; i++) {
+            this.inventory.put( (char) (i + 97), 0);
+        }
+    }
+
+    // returns private inventory.
+    private Map<Character, Integer> getInventory() {
+        return this.inventory;
+    }
+    
+    // test whether character is in inventory.
+    private boolean has(Character character) {
+        return this.getInventory().keySet().contains(Character.toLowerCase(character));
+    }
+
+    // decrements inventory count of character in inventory.
+    private void subtract(Character character) {
+        if( ! this.has(character) || this.get(character) <= 0 ) {
+            return;
+        } else {
+            int count = this.get(character);
+            count--;
+            this.set(character, count);
+        }
+    }
+
+    // increments inventory count of character in inventory.
+    private void add(Character character) {
+        if( ! this.has(character) ) {
+            return;
+        } else {
+            int count = this.get(character);
+            this.set(character, count + 1);
+        }
+    }
+}

src/main/java/com/matthewjensen/project/modules/anagrams/README.md

@@ -0,0 +1,6 @@
+# Anagrams
+
+This program focuses on recursive backtracking.
+
+# Description
+A class called Anagrams that uses a dictionary to find all anagram phrases that match a given word or phrase. You are provided with a client program AnagramMain that prompts the user for phrases and then passes those phrases to your Anagrams object. It asks your object to print all anagrams for those phrases.

src/main/java/com/matthewjensen/project/modules/anagrams/Recursion.java

@@ -0,0 +1,41 @@
+import java.util.*;
+
+public interface Recursion {
+    public static void main(String[] args) {
+
+    }
+    private boolean findSolutions(int n) {
+        // check if solution
+        boolean foundSolution = false;
+        if(foundSolution) {
+            displaySolution();
+            return true;
+        }
+        // guesses.
+        List<String> values = new ArrayList<String>();
+        for( String value : values ) {
+            if( isValid(value, n) ) {
+                applyValue(value, n);
+                if( findSolutions(n - 1) ) {
+                    return true;
+                }
+                removeValue(value, n);
+            }
+
+        }
+        return false;
+    }
+
+    private boolean isValid(String value, int n) {
+        return true;
+    }
+    private void removeValue(String value, int n) {
+
+    }
+    private void applyValue(String value, int n) {
+
+    }
+    private void displaySolution() {
+        System.out.println();
+    }
+}

src/main/java/com/matthewjensen/project/modules/anagrams/dict1.txt

@@ -0,0 +1,60 @@
+abash
+aura
+bar
+barb
+bee
+beg
+blush
+bog
+bogus
+bough
+bow
+brew
+briar
+brow
+brush
+bug
+bugs
+bus
+but
+egg
+ego
+erg
+ghost
+go
+goes
+gorge
+gosh
+grew
+grow
+grub
+gush
+he
+her
+here
+hew
+hog
+hose
+how
+hub
+hug
+huh
+hush
+owe
+rub
+sew
+she
+shrub
+shrug
+sir
+sub
+surge
+swore
+web
+wee
+were
+whore
+whose
+woe
+wore
+worse

src/main/java/com/matthewjensen/project/modules/calendar/Assignment3.java

@@ -0,0 +1,495 @@
+/**
+*
+* Matt Jensen
+* 3/20/19
+*
+* Draws a basic calendar to the console.
+* Calendar is scalable with a class constant.
+* = and | characters are used for the boundary of the calendar.
+*
+*/
+
+import java.util.*; // uses scanner
+import java.io.*; // uses file
+
+public class Assignment3 {
+
+    public static final String[][] EVENTS = new String[12][];
+    public static final String[] OPTIONS = {"e", "t", "n", "p", "q", "ev", "fp"};
+    public static final String[] OPTION_DESC = { 
+        "to enter a date and display the corresponding calendar",
+        "to get todays date and display the today's calendar",
+        "to display the next month",
+        "to display the previous month",
+        "to quit the program",
+        "event mode",
+        "file print mode",
+    };
+
+    /**
+    *
+    * The width of a single cell of the calendar.
+    *
+    */
+    public static final int CELL_WIDTH = 10;
+
+    /**
+    * 
+    * Prompts user for a date input on the console.
+    * Parses input of the form "mm/dd".
+    * Displays month in the top of output.
+    * Displays mm and dd separately at the bottom.
+    * Displays the month associated with input.
+    * Displays current month in same format below.
+    *
+    */
+    public static void main(String [] args) {
+        Scanner console = new Scanner(System.in);
+        int month, day = 1;
+        int currentYear, newYear = 0;
+        Calendar date = Calendar.getInstance();
+        setEventYear(date.get(Calendar.YEAR));
+        currentYear = date.get(Calendar.YEAR);
+        
+        String option = promptForOption(console);
+        while( ! option.equals("q") ) {
+            //"to enter a date and display the corresponding calendar",
+            //"to display the previous month",
+            if( option.equals("ev") ) {
+                String eventLine = promptForEvent(console);
+                addEvent(eventFromLine(eventLine));
+            }
+            else if(option.equals("fp") ) {
+                File file = promptForFile(console);
+                try{
+                    PrintStream out = new PrintStream(file);
+                    String dateLine = promptForDateLine(console);
+                    month = monthFromLine(dateLine);
+                    day = dayFromLine(dateLine);
+                    date.set(Calendar.getInstance().get(Calendar.YEAR), month, day);
+                    drawCalendar(date, out); // draw the month
+                    out.close();
+                }
+                catch(FileNotFoundException error) {
+                    continue;
+                }
+            }
+            else {
+                if(option.equals("e") ) {
+                    String dateLine = promptForDateLine(console);
+                    // input 
+                    month = monthFromLine(dateLine);
+                    day = dayFromLine(dateLine);
+                    date.set(Calendar.getInstance().get(Calendar.YEAR), month, day);
+                }
+                //"to get todays date and display the today's calendar",
+                if( option.equals("t") ) {
+                    // current
+                    date = Calendar.getInstance();
+                }
+                //"to display the next month",
+                if( option.equals("n") ) {
+                    date.add(Calendar.MONTH, 1);
+                }
+                //"to display the previous month",
+                if(option.equals("p") ) {
+                    date.add(Calendar.MONTH, -1);
+                }
+                newYear = date.get(Calendar.YEAR);
+                if(newYear != currentYear) {
+                    setEventYear(newYear);
+                }
+                
+                drawCalendar(date, System.out); // draw the month
+            }
+            option = promptForOption(console);
+        }
+    }
+
+    // read in a file of events if they exists
+    public static void loadEventsFile() {
+        File eventFile = new File("calendarEvents.txt");
+        if( ! eventFile.exists()) {
+           return; 
+        }
+        try {   
+            Scanner fileScanner = new Scanner(eventFile);
+            while( fileScanner.hasNextLine() ) {
+                String eventLine = fileScanner.nextLine();
+                addEvent(eventFromLine(eventLine));
+            }
+        }
+        catch(FileNotFoundException notFound){
+            return;
+        }
+    }
+
+    // prompt loop for file name of file to print to
+    public static File promptForFile(Scanner console){
+        System.out.println("What filename? (example.txt)");
+        System.out.println();
+        String input = console.next();
+        File file = new File(input);
+        return file;
+    }
+
+    // prompt loop for a (mm/dd) date input
+    public static String promptForDateLine(Scanner console){
+            System.out.println("What date would you like displayed? (mm/dd)");
+            System.out.println();
+            String input = console.next();
+            while( ! validDateInput(input) ) {
+                System.out.println("Try again.");
+                System.out.println("What date would you like displayed? (mm/dd)");
+                input = console.next();
+            }
+        return input;
+    }
+
+    // event name of given calendar date
+    public static String getEventForDate(Calendar date) {
+        int month = date.get(Calendar.MONTH);
+        int day = date.get(Calendar.DAY_OF_MONTH) - 1;
+        String eventName = EVENTS[month][day];
+        if(eventName == null) {
+            return "";
+        }
+        return eventName;
+    }
+    /**
+    *
+    * extract an event name from line
+    *
+    * @param    eventLine   mm/dd event_name parsing.
+    * @return   month   day substring of the given date.
+    *
+    */
+    public static String[] eventFromLine(String line) {
+        Scanner scanner = new Scanner(line);
+        String month = Integer.toString(monthFromLine(line));
+        String day = Integer.toString(dayFromLine(line));
+        String rawDate = scanner.next();
+        String name = scanner.next();
+        String[] event = {month, day, name};
+        return event;
+    }
+
+    // add event name to multi dem. class array of events
+    public static void addEvent(String[] event) {
+        int month = Integer.parseInt(event[0]);
+        int day = Integer.parseInt(event[1]) - 1;
+        String name = event[2];
+        EVENTS[month][day] = name; 
+    }
+
+    // is the event line valid?
+    public static boolean validEventInput(String input) {
+        if( ! validDateInput(input) ) {
+            System.out.println("Error: Bad date.");
+            return false;
+        }
+        Scanner scanner = new Scanner(input);
+        String rawDate = scanner.next();
+        if( ! scanner.hasNext() ) {
+            System.out.println("Error: No event.");
+            return false;
+        }
+        return true;
+    }
+    
+    // regenerate EVENTS with new day quantities.
+    // reloads events file automatically.
+    public static void setEventYear(int year){
+        Calendar cal = Calendar.getInstance();
+        cal.set(Calendar.YEAR, year);
+        cal.set(Calendar.MONTH, 1); 
+        cal.set(Calendar.DAY_OF_MONTH, 1); 
+        String[][] clone = EVENTS.clone();
+        //TODO: copy events to new year
+        for(int i = 0; i < 12; i++) {
+            EVENTS[i] = new String[cal.getMaximum(Calendar.DAY_OF_MONTH)];
+        }
+        loadEventsFile();
+    }
+    
+    // prompt loop for events
+    public static String promptForEvent(Scanner console) {
+        System.out.println("Please type an event (mm/dd event_name)");
+        System.out.println();
+
+        String input = console.next() + " " + console.next();
+        while( ! validEventInput(input) ) {
+            System.out.println("Try again.");
+            System.out.println("Please type an event (mm/dd event_name)");
+            input = console.next() + " " + console.next();
+        }
+        return input;
+    } 
+
+    // prompt loop for options
+    public static String promptForOption(Scanner console) {
+        System.out.println("Please type a command");
+        printOptions();
+        String input = console.next();
+        while(  ! validInput(input) ) {
+            System.out.println("Please enter a valid command");
+            System.out.println("Please type a command");
+            printOptions();
+            input = console.next();
+            System.out.println();
+        }
+        return input.toLowerCase();
+    } 
+
+    // valid date line input?
+    public static boolean validDateInput(String input) {
+        Scanner scanner = new Scanner(input);
+
+        if( ! scanner.hasNext() ) {
+            System.out.println("Error: No Date Detected");
+            return false;
+        }
+        String rawDate = scanner.next();
+        scanner = new Scanner(rawDate.replace('/', ' '));
+        if( ! scanner.hasNextInt() ) {
+            System.out.println("Error: No Month");
+            return false;
+        }
+        int month = scanner.nextInt();
+
+        if( ! scanner.hasNextInt() ) {
+            System.out.println("Error: No Day");
+            return false;
+        }
+        int day = scanner.nextInt();
+
+        if(month > 12 || month < 1 || day < 1 || day > 31) {
+            System.out.println("Error: Date out of bounds");
+            return false;
+        }
+        return true;
+    }
+
+    // prints the available options array
+    public static void printOptions() {
+        for(int i = 0; i < OPTIONS.length; i++) {
+            System.out.println("\"" + OPTIONS[i] + "\" " + OPTION_DESC[i]);
+        }
+    }
+
+    // valid option input?
+    public static boolean validInput(String input) {
+        String option = input.toLowerCase();
+        String regex = "(" + String.join("|", OPTIONS) + ").*";
+        //System.out.println(regex); 
+        if( option.matches(regex) ) {
+            return true;
+        }
+        return false;
+    }
+
+
+    /**
+    *
+    * draws a given month
+    *
+    * @param    date    which date
+    * @param    out     where to print
+    * @return   void
+    *
+    */
+    public static void drawCalendar(Calendar date, PrintStream out) {
+    
+        out.println();
+        out.printf("Month: %-" + (calendarWidth() - 8) + "s\n", date.get(Calendar.MONTH) + 1);
+
+        // rows
+        drawDivider('=', out);
+        drawHeader(out);
+        drawDivider('=', out);
+        Calendar firstDay = (Calendar) date.clone();
+        firstDay.set(Calendar.WEEK_OF_MONTH, 1);
+        firstDay.set(Calendar.DAY_OF_WEEK, 1);
+        for(int weekNumber = 0; weekNumber < date.getActualMaximum(Calendar.WEEK_OF_MONTH); weekNumber++) {
+            drawWeekStartingOn(firstDay, date, out);
+            drawDivider('-', out);
+            firstDay.add(Calendar.DAY_OF_MONTH, 7);
+        }
+        
+        out.println();
+        int month = date.get(Calendar.MONTH);
+        int day = date.get(Calendar.DAY_OF_MONTH);
+        drawDate(month, day, out); // display date
+    }
+
+    // calculated the total width of the calendar.
+    public static int calendarWidth() {
+        int totalWidth = CELL_WIDTH * 7;
+        return totalWidth;
+    }
+
+    /**
+    *
+    * draws a single row of the calenday to console.
+    *
+    * @param    row     the row number to print.
+    * @return   void
+    *
+    */
+    public static void drawWeekStartingOn(Calendar firstDayOfWeek, Calendar date, PrintStream out) {
+        Calendar currentDate = (Calendar) firstDayOfWeek.clone();
+        Calendar lastDayOfWeek = (Calendar) firstDayOfWeek.clone();
+        lastDayOfWeek.add(Calendar.DAY_OF_MONTH, 6);
+        while(! currentDate.after(lastDayOfWeek)) {
+            int day = currentDate.get(Calendar.DAY_OF_MONTH);
+            String content = "";
+            if( currentDate.get(Calendar.MONTH) == date.get(Calendar.MONTH)) { // valid dates only
+                if(currentDate.equals(date)) {
+                    content += "*";
+                }
+                content += day;
+            }
+            out.print("|");
+            out.printf("%" + (CELL_WIDTH - 1) + "s", content);
+            currentDate.add(Calendar.DAY_OF_MONTH, 1);
+        }
+        out.println("|");
+
+        for(int i = 0; i < CELL_WIDTH / 2; i++) {
+            currentDate = (Calendar) firstDayOfWeek.clone();
+            while(! currentDate.after(lastDayOfWeek)) {
+                String content = "";
+                if(i == 0) {
+                    String eventName = getEventForDate(currentDate);
+                    content += eventName;
+                    if (content.length() > CELL_WIDTH) {
+                        content = content.substring(0, CELL_WIDTH - 4) + "...";
+                    }
+                }
+                out.print("|");
+                out.printf("%" + (CELL_WIDTH - 1) + "s", content);
+                currentDate.add(Calendar.DAY_OF_MONTH, 1);
+            }
+            out.println("|");
+        }
+    }
+
+
+    // draws divider with given char
+    public static void drawDivider(char character, PrintStream out) {
+        out.print(' ');
+        for(int i = 0; i < calendarWidth() - 1; i++) {
+            out.print(character);
+        }
+        out.println();
+    }
+
+    // draws day names
+    public static void drawHeader(PrintStream out) {
+        String[] strDays = new String[] { "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa" };
+        Calendar cal = Calendar.getInstance();
+        cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
+        while(cal.get(Calendar.DAY_OF_WEEK) < 7) {
+            out.printf("| %-" + (CELL_WIDTH - 2) + "s", strDays[cal.get(Calendar.DAY_OF_WEEK) - 1 ]);
+            cal.add(Calendar.DAY_OF_WEEK, 1);
+        }
+        out.printf("| %-" + (CELL_WIDTH - 2) + "s|\n", strDays[cal.get(Calendar.DAY_OF_WEEK) - 1 ]);
+
+    }
+
+    /**
+    *
+    * prints the month and date on two separate lines.
+    *
+    * @param    month   month for printing.
+    * @param    day   day for printing.
+    * @return   void
+    *
+    */
+    public static void drawDate(int month, int day, PrintStream out) {
+        out.printf("Month: %" + CELL_WIDTH +"s\n", month + 1);
+        out.printf("Day:   %" + CELL_WIDTH +"s\n", day);
+    }
+
+    /**
+    *
+    * extract an integer value for the month from a given string.
+    *
+    * @param    date   date string of the form mm/dd.
+    * @return   month   month substring of the given date.
+    *
+    */
+    public static int monthFromLine(String line) {
+        Scanner scanner = new Scanner(line.replace('/', ' '));
+        int month = scanner.nextInt();
+        return month - 1;
+    }
+
+    /**
+    *
+    * extract an integer value for the day from a given string.
+    *
+    * @param    date   date string of the form mm/dd.
+    * @return   month   day substring of the given date.
+    *
+    */
+    public static int dayFromLine(String line) {
+        Scanner scanner = new Scanner(line.replace('/', ' '));
+        int month = scanner.nextInt();
+        int day = scanner.nextInt();
+        return day;
+    }
+
+
+    /**
+    *
+    * draws ASCII art preamble of the calendar
+    *
+    * @return   void
+    *
+    */
+    public static void drawArt() {
+        int calHeight = 7 * CELL_WIDTH;
+        //top
+        printChar('_', calHeight);
+
+        //sun
+        System.out.println();
+        System.out.print(" ");
+        printChar('_', calHeight/4);
+        System.out.println(" ");
+        for(int i = 0; i < calHeight/10; i++) {
+            System.out.print("|");
+            printChar(' ', calHeight/4);
+            System.out.println("|");
+        }
+        System.out.print("|");
+        printChar('_', calHeight/4);
+        System.out.println("|");
+
+
+        //beam
+        System.out.println();
+        for(int line = 0; line < calHeight/ 3; line++) {
+            printChar(' ', line / 2);
+            System.out.print("\\");
+            printChar('\\', line / 2);
+            printChar(' ', line / 2);
+            System.out.println();
+        }
+
+        //windows
+        printChar('_', calHeight);
+        System.out.println();
+        System.out.println();
+        
+        //banner
+        //wheels
+    }
+
+    public static void printChar(char character, int count) {
+        for(int i = 0; i < count; i++) {
+            System.out.print(character);
+        }
+    }
+}

src/main/java/com/matthewjensen/project/modules/calendar/README.md

@@ -0,0 +1,10 @@
+# Topics:
+File I/o (input / output), Arrays
+
+## Learning Outcomes:
+
+- Practice Reading in files to java and processing file text content
+- Become comfortable with using arrays to store and retrieve data
+- Design and develop programs in accepted style
+- Develop further the ability to enhance a program to increase functionality
+- Execute the proper steps to write out desired content to a file

src/main/java/com/matthewjensen/project/modules/calendar/calendarEvents.txt

@@ -0,0 +1,10 @@
+01/01 New_Year's_Day
+01/15 Martin_Luther_King,_Jr._Day
+02/19 President's_Day
+05/28 Memorial_Day
+07/04 Independence_Day
+09/03 Labor_Day
+10/08 Columbus_Day
+11/12 Veterans_Day
+11/22 Thanksgiving_Day
+12/25 Christmas_Day

src/main/java/com/matthewjensen/project/modules/critters/Bear.java

@@ -0,0 +1,54 @@
+/*
+*
+* Matt Jensen
+* CS145
+* Lab 2 - Critters
+* 4/23/19
+* Partners: Melissa, Devante
+* 
+*/
+import java.awt.*;
+import java.util.*;
+
+public class Bear extends Critter {
+    private Color color = Color.BLACK;
+    private String symbol = "/";
+    // white if polar
+    public Bear(boolean polar) {
+        if(polar) {
+            this.color = Color.WHITE;
+        }
+        if( Math.random() > 0.5) {
+            this.changeSymbol();
+        }
+    }
+    //getter
+    public Color getColor() {
+        return this.color;
+    }
+    //getter
+    public String toString() {
+        return this.symbol;
+    }
+    public Action getMove(CritterInfo info) {
+        this.changeSymbol();
+        Neighbor front = info.getFront();
+        if( front == Neighbor.OTHER ) { // check for enemy in front.
+            return Action.INFECT;
+        }
+        if ( front == Neighbor.EMPTY ) { // check for obstacle.
+            return Action.HOP;
+        }
+        return Action.LEFT;
+    }
+    // toggles between / and \
+    public void changeSymbol() {
+        if(this.symbol.equals("/")) {
+            this.symbol = "\\";
+        }
+        else {
+            this.symbol = "/";
+        }
+    }
+
+}

src/main/java/com/matthewjensen/project/modules/critters/Critter.java

@@ -0,0 +1,62 @@
+// This is the superclass of all of the Critter classes.  Your class should
+// extend this class.  The class provides several kinds of constants:
+//
+//    type Neighbor  : WALL, EMPTY, SAME, OTHER
+//    type Action    : HOP, LEFT, RIGHT, INFECT
+//    type Direction : NORTH, SOUTH, EAST, WEST
+//
+// Override the following methods to change the behavior of your Critter:
+//
+//     public Action getMove(CritterInfo info)
+//     public Color getColor()
+//     public String toString()
+//
+// The CritterInfo object passed to the getMove method has the following
+// available methods:
+//
+//     public Neighbor getFront();            neighbor in front of you
+//     public Neighbor getBack();             neighbor in back of you
+//     public Neighbor getLeft();             neighbor to your left
+//     public Neighbor getRight();            neighbor to your right
+//     public Direction getDirection();       direction you are facing
+//     public Direction getFrontDirection();  direction of front neighbor
+//     public Direction getBackDirection();   direction of back neighbor
+//     public Direction getLeftDirection();   direction of left neighbor
+//     public Direction getRightDirection();  direction of right neighbor
+
+import java.awt.*;
+
+public class Critter {
+    public static enum Neighbor {
+        WALL, EMPTY, SAME, OTHER
+    };
+
+    public static enum Action {
+        HOP, LEFT, RIGHT, INFECT
+    };
+
+    public static enum Direction {
+        NORTH, SOUTH, EAST, WEST
+    };
+
+    // This method should be overriden (default action is turning left)
+    public Action getMove(CritterInfo info) {
+        return Action.LEFT;
+    }
+
+    // This method should be overriden (default color is black)
+    public Color getColor() {
+        return Color.BLACK;
+    }
+
+    // This method should be overriden (default display is "?")
+    public String toString() {
+        return "?";
+    }
+
+    // This prevents critters from trying to redefine the definition of
+    // object equality, which is important for the simulator to work properly.
+    public final boolean equals(Object other) {
+        return this == other;
+    }
+}

src/main/java/com/matthewjensen/project/modules/critters/CritterFrame.java

@@ -0,0 +1,203 @@
+// Class CritterFrame provides the user interface for a simple simulation
+// program.
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.event.*;
+import java.util.*;
+
+public class CritterFrame extends JFrame {
+    private CritterModel myModel;
+    private CritterPanel myPicture;
+    private javax.swing.Timer myTimer;
+    private JButton[] counts;
+    private JButton countButton;
+    private boolean started;
+    private static boolean created;
+    
+    public CritterFrame(int width, int height) {
+        // this prevents someone from trying to create their own copy of
+        // the GUI components
+        if (created)
+            throw new RuntimeException("Only one world allowed");
+        created = true;
+
+        // create frame and model
+        setTitle("CSE142 critter simulation");
+        setDefaultCloseOperation(EXIT_ON_CLOSE);
+        myModel = new CritterModel(width, height);
+
+        // set up critter picture panel
+        myPicture = new CritterPanel(myModel);
+        add(myPicture, BorderLayout.CENTER);
+
+        addTimer();
+
+        constructSouth();
+
+        // initially it has not started
+        started = false;
+    }
+
+    // construct the controls and label for the southern panel
+    private void constructSouth() {
+        // add timer controls to the south
+        JPanel p = new JPanel();
+
+        final JSlider slider = new JSlider();
+        slider.addChangeListener(new ChangeListener() {
+            public void stateChanged(ChangeEvent e) {
+                double ratio = 1000.0 / (1 + Math.pow(slider.getValue(), 0.3));
+                myTimer.setDelay((int) (ratio - 180));
+            }
+        });
+        slider.setValue(20);
+        p.add(new JLabel("slow"));
+        p.add(slider);
+        p.add(new JLabel("fast"));
+
+        JButton b1 = new JButton("start");
+        b1.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                myTimer.start();
+            }
+        });
+        p.add(b1);
+        JButton b2 = new JButton("stop");
+        b2.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                myTimer.stop();
+            }
+        });
+        p.add(b2);
+        JButton b3 = new JButton("step");
+        b3.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                doOneStep();
+            }
+        });
+        p.add(b3);
+        
+        // add debug button
+        JButton b4 = new JButton("debug");
+        b4.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                myModel.toggleDebug();
+                myPicture.repaint();
+            }
+        });
+        p.add(b4);
+
+        // add 100 button
+        JButton b5 = new JButton("next 100");
+        b5.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                multistep(100);
+            }
+        });
+        p.add(b5);
+
+        add(p, BorderLayout.SOUTH);
+    }
+
+    // starts the simulation...assumes all critters have already been added
+    public void start() {
+        // don't let anyone start a second time and remember if we have started
+        if (started) {
+            return;
+        }
+        // if they didn't add any critters, then nothing to do
+        if (myModel.getCounts().isEmpty()) {
+            System.out.println("nothing to simulate--no critters");
+            return;
+        }
+        started = true;
+        addClassCounts();
+        myModel.updateColorString();
+        pack();
+        setVisible(true);
+    }
+
+    // add right-hand column showing how many of each critter are alive
+    private void addClassCounts() {
+        Set<Map.Entry<String, Integer>> entries = myModel.getCounts();
+        JPanel p = new JPanel(new GridLayout(entries.size() + 1, 1));
+        counts = new JButton[entries.size()];
+        for (int i = 0; i < counts.length; i++) {
+            counts[i] = new JButton();
+            p.add(counts[i]);
+        }
+
+        // add simulation count
+        countButton = new JButton();
+        countButton.setForeground(Color.BLUE);
+        p.add(countButton);
+
+        add(p, BorderLayout.EAST);
+        setCounts();
+    }
+
+    private void setCounts() {
+        Set<Map.Entry<String, Integer>> entries = myModel.getCounts();
+        int i = 0;
+        int max = 0;
+        int maxI = 0;
+        for (Map.Entry<String, Integer> entry: myModel.getCounts()) {
+            String s = String.format("%s =%4d", entry.getKey(),
+                                     (int) entry.getValue());
+            counts[i].setText(s);
+            counts[i].setForeground(Color.BLACK);
+            if (entry.getValue() > max) {
+                max = entry.getValue();
+                maxI = i;
+            }
+            i++;
+        }
+        counts[maxI].setForeground(Color.RED);
+        String s = String.format("step =%5d", myModel.getSimulationCount());
+        countButton.setText(s);
+    }
+
+    // add a certain number of critters of a particular class to the simulation
+    public void add(int number, Class<? extends Critter> c) {
+        // don't let anyone add critters after simulation starts
+        if (started) {
+            return;
+        }
+        // temporarily turning on started flag prevents critter constructors
+        // from calling add
+        started = true;
+        myModel.add(number, c);
+        started = false;
+    }
+
+    // post: creates a timer that calls the model's update
+    //       method and repaints the display
+    private void addTimer() {
+        ActionListener updater = new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                doOneStep();
+            }
+        };
+        myTimer = new javax.swing.Timer(0, updater);
+        myTimer.setCoalesce(true);
+    }
+
+    // one step of the simulation
+    private void doOneStep() {
+        myModel.update();
+        setCounts();
+        myPicture.repaint();
+    }
+
+    // advance the simulation until step % n is 0
+    private void multistep(int n) {
+        myTimer.stop();
+        do {
+            myModel.update();
+        } while (myModel.getSimulationCount() % n != 0);
+        setCounts();
+        myPicture.repaint();
+    }
+}

src/main/java/com/matthewjensen/project/modules/critters/CritterInfo.java

@@ -0,0 +1,15 @@
+// The CritterInfo interface defines a set of methods for querying the
+// state of a critter simulation.  You should not alter this file.  See
+// the documentation in the Critter class for a more detailed explanation.
+
+public interface CritterInfo {
+    public Critter.Neighbor getFront();
+    public Critter.Neighbor getBack();
+    public Critter.Neighbor getLeft();
+    public Critter.Neighbor getRight();
+    public Critter.Direction getDirection();
+    public Critter.Direction getFrontDirection();
+    public Critter.Direction getBackDirection();
+    public Critter.Direction getLeftDirection();
+    public Critter.Direction getRightDirection();
+}

src/main/java/com/matthewjensen/project/modules/critters/CritterMain.java

@@ -0,0 +1,25 @@
+// CSE 142 Homework 9 (Critters)
+// Authors: Stuart Reges and Marty Stepp
+//          modified by Kyle Thayer
+//
+// CritterMain provides the main method for a simple simulation program.  Alter
+// the number of each critter added to the simulation if you want to experiment
+// with different scenarios.  You can also alter the width and height passed to
+// the CritterFrame constructor.
+
+public class CritterMain {
+    public static void main(String[] args) {
+        CritterFrame frame = new CritterFrame(60, 40);
+
+        // uncomment each of these lines as you complete these classes
+        frame.add(30, Bear.class);
+        frame.add(30, Lion.class);
+        frame.add(30, Giant.class);
+        frame.add(30, Orca.class);
+
+        frame.add(30, FlyTrap.class);
+        frame.add(30, Food.class);
+
+        frame.start();
+    }
+}

src/main/java/com/matthewjensen/project/modules/critters/CritterModel.java

@@ -0,0 +1,327 @@
+// Class CritterModel keeps track of the state of the critter simulation.
+
+import java.util.*;
+import java.awt.Point;
+import java.awt.Color;
+import java.lang.reflect.*;
+
+public class CritterModel {
+    private int height;
+    private int width;
+    private Critter[][] grid;
+    private Map<Critter, PrivateData> info;
+    private SortedMap<String, Integer>critterCount;
+    private boolean debugView;
+    private int simulationCount;
+    private static boolean created;
+    
+    public CritterModel(int width, int height) {
+        // this prevents someone from trying to create their own copy of
+        // the GUI components
+        if (created)
+            throw new RuntimeException("Only one world allowed");
+        created = true;
+
+        this.width = width;
+        this.height = height;
+        grid = new Critter[width][height];
+        info = new HashMap<Critter, PrivateData>();
+        critterCount = new TreeMap<String, Integer>();
+        this.debugView = false;
+    }
+
+    public Iterator<Critter> iterator() {
+        return info.keySet().iterator();
+    }
+
+    public Point getPoint(Critter c) {
+        return info.get(c).p;
+    }
+
+    public Color getColor(Critter c) {
+        return info.get(c).color;
+    }
+
+    public String getString(Critter c) {
+        return info.get(c).string;
+    }
+
+    public void add(int number, Class<? extends Critter> critter) {
+        Random r = new Random();
+        Critter.Direction[] directions = Critter.Direction.values();
+        if (info.size() + number > width * height)
+            throw new RuntimeException("adding too many critters");
+        for (int i = 0; i < number; i++) {
+            Critter next;
+            try {
+                next = makeCritter(critter);
+            } catch (IllegalArgumentException e) {
+                System.out.println("ERROR: " + critter + " does not have" +
+                                   " the appropriate constructor.");
+                System.exit(1);
+                return;
+            } catch (Exception e) {
+                System.out.println("ERROR: " + critter + " threw an " +
+                                   " exception in its constructor.");
+                System.exit(1);
+                return;
+            }
+            int x, y;
+            do {
+                x = r.nextInt(width);
+                y = r.nextInt(height);
+            } while (grid[x][y] != null);
+            grid[x][y] = next;
+            
+            Critter.Direction d = directions[r.nextInt(directions.length)];
+            info.put(next, new PrivateData(new Point(x, y), d));
+        }
+        String name = critter.getName();
+        if (!critterCount.containsKey(name))
+            critterCount.put(name, number);
+        else
+            critterCount.put(name, critterCount.get(name) + number);
+    }
+
+    @SuppressWarnings("unchecked")
+    private Critter makeCritter(Class critter) throws Exception {
+        Constructor c = critter.getConstructors()[0];
+        if (critter.toString().equals("class Bear")) {
+            // flip a coin
+            boolean b = Math.random() < 0.5;
+            return (Critter) c.newInstance(new Object[] {b});
+        } else {
+            return (Critter) c.newInstance();
+        }
+    }
+
+    public int getWidth() {
+        return width;
+    }
+
+    public int getHeight() {
+        return height;
+    }
+
+    public String getAppearance(Critter c) {
+        // Override specified toString if debug flag is true
+        if (!debugView) 
+            return info.get(c).string;
+        else {
+            PrivateData data = info.get(c);
+            if (data.direction == Critter.Direction.NORTH) return "^";
+            else if (data.direction == Critter.Direction.SOUTH) return "v";
+            else if (data.direction == Critter.Direction.EAST) return ">";
+            else return "<";
+        }
+    }
+    
+    public void toggleDebug() {
+        this.debugView = !this.debugView;
+    }
+
+    private boolean inBounds(int x, int y) {
+        return (x >= 0 && x < width && y >= 0 && y < height);
+    }
+
+    private boolean inBounds(Point p) {
+        return inBounds(p.x, p.y);
+    }
+
+    // returns the result of rotating the given direction clockwise
+    private Critter.Direction rotate(Critter.Direction d) {
+        if (d == Critter.Direction.NORTH) return Critter.Direction.EAST;
+        else if (d == Critter.Direction.SOUTH) return Critter.Direction.WEST;
+        else if (d == Critter.Direction.EAST) return Critter.Direction.SOUTH;
+        else return Critter.Direction.NORTH;
+    }
+
+    private Point pointAt(Point p, Critter.Direction d) {
+        if (d == Critter.Direction.NORTH) return new Point(p.x, p.y - 1);
+        else if (d == Critter.Direction.SOUTH) return new Point(p.x, p.y + 1);
+        else if (d == Critter.Direction.EAST) return new Point(p.x + 1, p.y);
+        else return new Point(p.x - 1, p.y);
+    }
+
+    private Info getInfo(PrivateData data, Class original) {
+        Critter.Neighbor[] neighbors = new Critter.Neighbor[4];
+        Critter.Direction d = data.direction;
+        Critter.Direction[] neighborDirections = new Critter.Direction[4];
+        for (int i = 0; i < 4; i++) {
+            neighbors[i] = getStatus(pointAt(data.p, d), original);
+            if (neighbors[i] == Critter.Neighbor.OTHER ||
+                neighbors[i] == Critter.Neighbor.SAME){
+               Point p = pointAt(data.p, d);
+               PrivateData oldData = info.get(grid[p.x][p.y]);
+               neighborDirections[i] = oldData.direction;
+            } else {
+               neighborDirections[i] = Critter.Direction.NORTH;
+            }
+            d = rotate(d);
+        }
+        return new Info(neighbors, data.direction, neighborDirections);
+    }
+
+    private Critter.Neighbor getStatus(Point p, Class original) {
+        if (!inBounds(p))
+            return Critter.Neighbor.WALL;
+        else if (grid[p.x][p.y] == null)
+            return Critter.Neighbor.EMPTY;
+        else if (grid[p.x][p.y].getClass() == original)
+            return Critter.Neighbor.SAME;
+        else
+            return Critter.Neighbor.OTHER;
+    }
+
+    @SuppressWarnings("unchecked")
+    public void update() {
+        simulationCount++;
+        Object[] list = info.keySet().toArray();
+        Collections.shuffle(Arrays.asList(list));
+
+        // This keeps track of critters that are locked and cannot be 
+        // infected this turn. The happens when: 
+        // * a Critter is infected
+        // * a Critter hops
+        Set<Critter> locked = new HashSet<Critter>();
+        
+        for (int i = 0; i < list.length; i++) {
+            Critter next = (Critter)list[i];
+            PrivateData data = info.get(next);
+            if (data == null) {
+                // happens when creature was infected earlier in this round
+                continue;
+            }
+            Point p = data.p;
+            Point p2 = pointAt(p, data.direction);
+
+            
+            // try to perform the critter's action
+            Critter.Action move = next.getMove(getInfo(data, next.getClass()));
+            if (move == Critter.Action.LEFT)
+                data.direction = rotate(rotate(rotate(data.direction)));
+            else if (move == Critter.Action.RIGHT)
+                data.direction = rotate(data.direction);
+            else if (move == Critter.Action.HOP) {
+                if (inBounds(p2) && grid[p2.x][p2.y] == null) {
+                    grid[p2.x][p2.y] = grid[p.x][p.y];
+                    grid[p.x][p.y] = null;
+                    data.p = p2;
+                    locked.add(next); //successful hop locks a critter from
+                                      // being infected for the rest of the
+                                      // turn
+                }
+            } else if (move == Critter.Action.INFECT) {
+                if (inBounds(p2) && grid[p2.x][p2.y] != null
+                    && grid[p2.x][p2.y].getClass() != next.getClass()
+                    && !locked.contains(grid[p2.x][p2.y])) {
+                    Critter other = grid[p2.x][p2.y];
+                    // remember the old critter's private data
+                    PrivateData oldData = info.get(other);
+                    // then remove that old critter
+                    String c1 = other.getClass().getName();
+                    critterCount.put(c1, critterCount.get(c1) - 1);
+                    String c2 = next.getClass().getName();
+                    critterCount.put(c2, critterCount.get(c2) + 1);
+                    info.remove(other);
+                    // and add a new one to the grid
+                    try {
+                        grid[p2.x][p2.y] = makeCritter(next.getClass());
+                        // This critter has been infected and is now locked
+                        // for the rest of this turn
+                        locked.add(grid[p2.x][p2.y]);
+                    } catch (Exception e) {
+                        throw new RuntimeException("" + e);
+                    }
+                    // and add to the map
+                    info.put(grid[p2.x][p2.y], oldData);
+                }
+            }
+        }
+        updateColorString();
+    }
+
+    // calling this method causes each critter to update the stored color and
+    // text for toString; should be called each time update is performed and
+    // once before the simulation begins
+    public void updateColorString() {
+        for (Critter next : info.keySet()) {
+            info.get(next).color = next.getColor();
+            info.get(next).string = next.toString();
+        }
+    }
+
+    public Set<Map.Entry<String, Integer>> getCounts() {
+        return Collections.unmodifiableSet(critterCount.entrySet());
+    }
+
+    public int getSimulationCount() {
+        return simulationCount;
+    }
+
+    private class PrivateData {
+        public Point p;
+        public Critter.Direction direction;
+        public Color color;
+        public String string;
+
+        public PrivateData(Point p, Critter.Direction d) {
+            this.p = p;
+            this.direction = d;
+        }
+
+        public String toString() {
+            return p + " " + direction;
+        }
+    }
+
+    // an object used to query a critter's state (neighbors, direction)
+    private static class Info implements CritterInfo {
+        private Critter.Neighbor[] neighbors;
+        private Critter.Direction direction;
+        private Critter.Direction[] neighborDirections;
+
+        public Info(Critter.Neighbor[] neighbors, Critter.Direction d,
+                    Critter.Direction[] neighborDirections) {
+            this.neighbors = neighbors;
+            this.direction = d;
+            this.neighborDirections = neighborDirections;
+        }
+
+        public Critter.Neighbor getFront() {
+            return neighbors[0];
+        }
+
+        public Critter.Neighbor getBack() {
+            return neighbors[2];
+        }
+
+        public Critter.Neighbor getLeft() {
+            return neighbors[3];
+        }
+
+        public Critter.Neighbor getRight() {
+            return neighbors[1];
+        }
+
+        public Critter.Direction getDirection() {
+            return direction;
+        }
+
+        public Critter.Direction getFrontDirection() {
+            return neighborDirections[0];
+        }
+        
+        public Critter.Direction getBackDirection() {
+            return neighborDirections[2];
+        }
+            
+        public Critter.Direction getLeftDirection() {
+            return neighborDirections[3];
+        }
+        
+        public Critter.Direction getRightDirection() {
+            return neighborDirections[1];
+        }
+    }
+}

src/main/java/com/matthewjensen/project/modules/critters/CritterPanel.java

@@ -0,0 +1,48 @@
+// Class CritterPanel displays a grid of critters
+
+import javax.swing.*;
+import java.awt.Point;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+
+public class CritterPanel extends JPanel {
+    private CritterModel myModel;
+    private Font myFont;
+    private static boolean created;
+
+    public static final int FONT_SIZE = 12;
+
+    public CritterPanel(CritterModel model) {
+        // this prevents someone from trying to create their own copy of
+        // the GUI components
+        if (created)
+            throw new RuntimeException("Only one world allowed");
+        created = true;
+
+        myModel = model;
+        // construct font and compute char width once in constructor
+        // for efficiency
+        myFont = new Font("Monospaced", Font.BOLD, FONT_SIZE + 4);
+        setBackground(Color.CYAN);
+        setPreferredSize(new Dimension(FONT_SIZE * model.getWidth() + 20,
+                                       FONT_SIZE * model.getHeight() + 20));
+    }
+
+    public void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        g.setFont(myFont);
+        Iterator<Critter> i = myModel.iterator();
+        while (i.hasNext()) {
+            Critter next = i.next();
+            Point p = myModel.getPoint(next);
+            String appearance = myModel.getAppearance(next);
+            g.setColor(Color.BLACK);
+            g.drawString("" + appearance, p.x * FONT_SIZE + 11,
+                         p.y * FONT_SIZE + 21);
+            g.setColor(myModel.getColor(next));
+            g.drawString("" + appearance, p.x * FONT_SIZE + 10,
+                         p.y * FONT_SIZE + 20);
+        }
+    }
+}

src/main/java/com/matthewjensen/project/modules/critters/FlyTrap.java

@@ -0,0 +1,23 @@
+// This defines a simple class of critters that infect whenever they can and
+// otherwise just spin around, looking for critters to infect.  This simple
+// strategy turns out to be surpisingly successful.
+
+import java.awt.*;
+
+public class FlyTrap extends Critter {
+    public Action getMove(CritterInfo info) {
+        if (info.getFront() == Neighbor.OTHER) {
+            return Action.INFECT;
+        } else {
+            return Action.LEFT;
+        }
+    }
+
+    public Color getColor() {
+        return Color.RED;
+    }
+
+    public String toString() {
+        return "T";
+    }
+}

src/main/java/com/matthewjensen/project/modules/critters/Food.java

@@ -0,0 +1,18 @@
+// This defines a simple class of critters that sit around waiting to be
+// taken over by other critters.
+
+import java.awt.*;
+
+public class Food extends Critter {
+    public Action getMove(CritterInfo info) {
+        return Action.INFECT;
+    }
+
+    public Color getColor() {
+        return Color.GREEN;
+    }
+
+    public String toString() {
+        return "F";
+    }
+}

src/main/java/com/matthewjensen/project/modules/critters/Giant.java

@@ -0,0 +1,63 @@
+/*
+*
+* Matt Jensen
+* CS145
+* Lab 2 - Critters
+* 4/23/19
+* Partners: Melissa, Devante
+* 
+*/
+import java.awt.*;
+import java.util.*;
+
+public class Giant extends Critter {
+    private Color color = Color.GRAY;
+    
+    private String symbol;
+    
+    public int moveCount;
+
+      
+    public Giant() {
+    }
+    
+    public Color getColor() {
+        return this.color;
+    }
+    
+    public String toString() {
+        this.changeSymbol();
+        return this.symbol;
+    }
+    
+    private void changeSymbol() {
+         if( this.moveCount > 24 ) {
+            this.moveCount = 0;
+         }
+         if( this.moveCount <= 6) {
+            this.symbol = "FEE";
+         }
+         if( this.moveCount > 6 && this.moveCount <= 12 ) {
+            this.symbol = "FIE";
+         }
+         if ( this.moveCount > 12 && this.moveCount <= 18) {
+            this.symbol = "FOO";
+         }
+         if ( this.moveCount > 18 ) {
+            this.symbol = "FUM";
+         }
+    }
+    
+    public Action getMove(CritterInfo info) {
+         this.moveCount++;
+         Neighbor front = info.getFront();
+         if( front == Neighbor.OTHER) {
+            return Action.INFECT;
+         }
+         if( front == Neighbor.EMPTY) {
+            return Action.HOP;
+         }
+         return Action.RIGHT;
+    }
+
+}

src/main/java/com/matthewjensen/project/modules/critters/Lion.java

@@ -0,0 +1,72 @@
+/*
+*
+* Matt Jensen
+* CS145
+* Lab 2 - Critters
+* 4/23/19
+* Partners: Melissa, Devante
+* 
+*/
+import java.awt.*;
+import java.util.*;
+
+public class Lion extends Critter {
+
+    private Color color = Color.BLUE;
+        
+    private int moves = 0;
+    
+    public Lion() {
+        this.changeColor();
+    }
+    
+    public int getMoveCount() {
+        return this.moves;
+    }
+
+    public Color getColor() {
+        return this.color;
+    }
+    
+    public String toString() {
+        return "L";
+    }
+    
+    public void changeColor() {
+        if(this.getMoveCount() == 0 || this.getMoveCount() % 3 == 0) {
+            int rand = this.randomWithRange(0, 2);
+            if(rand == 0 ) {
+                this.color = Color.RED;
+            }
+            if(rand == 1 ) {
+                this.color = Color.GREEN;
+            }
+            if(rand == 2 ) {
+                this.color = Color.BLUE;
+            }
+        }
+    }
+    public Action getMove(CritterInfo info) {
+        this.moves = this.moves++;
+        this.changeColor();
+        
+        Neighbor front = info.getFront();
+        
+        if( front == Neighbor.OTHER ) { // check for enemy in front.
+            return Action.INFECT;
+        }
+        if ( front == Neighbor.WALL || info.getRight() == Neighbor.WALL ) { // check for obstacle.
+            return Action.LEFT;
+        }
+        if ( front == Neighbor.SAME ) { // check for obstacle.
+            return Action.RIGHT;
+        }
+        return Action.HOP;
+    }
+    public int randomWithRange(int min, int max)
+    {
+        int range = (max - min) + 1;     
+        return (int)(Math.random() * range) + min;
+    }
+
+}

src/main/java/com/matthewjensen/project/modules/critters/Orca.java

@@ -0,0 +1,54 @@
+/*
+*
+* Matt Jensen
+* CS145
+* Lab 2 - Critters
+* 4/23/19
+* Partners: Melissa, Devante
+* 
+*/
+import java.awt.*;
+import java.util.*;
+
+public class Orca extends Critter {
+    private Color color = Color.BLACK;
+    
+    private String symbol = "0-<";
+    
+    public int moveCount;
+
+      
+    public Orca() {
+    }
+    
+    public Color getColor() {
+         if( this.color == Color.BLACK) {
+            this.color = Color.WHITE;
+         }
+         else{
+              this.color = Color.BLACK;
+         }
+        return this.color;
+    }
+    
+    public String toString() {
+        return this.symbol;
+    }
+    
+    public Action getMove(CritterInfo info) {
+         this.moveCount++;
+         Neighbor front = info.getFront();
+         
+         if(front == Neighbor.OTHER) {
+              return Action.INFECT;
+         }
+         if(front == Neighbor.EMPTY) {
+              return Action.HOP;
+         }
+         if(front == Neighbor.WALL) {
+              return Action.RIGHT;
+         }
+         return Action.LEFT;
+    }
+
+}

src/main/java/com/matthewjensen/project/modules/dna/DNA.java

@@ -0,0 +1,332 @@
+import java.util.*;
+import java.io.*;
+import java.text.*;
+
+public class DNA {
+
+    int MIN_CODONS = 5; //the minimum number of codons a valid protein must have
+    int MIN_MASS_PERCENT = 30; // the percentage of mass from C and G in order for a protein to be valid
+    int UNIQUE_NUCLEOTIDES = 4; // the number of unique nucleotides (representing A, C, G, and T)
+    public static final int CODONS_PER_NUCLEOTIDE = 3; // the number of nucleotides per codon 
+    public static final String INPUT_DIR = "input/"; // the number of nucleotides per codon 
+    public static final String OUTPUT_DIR = "output/"; // the number of nucleotides per codon 
+    public static final boolean DEBUG = false; // controls print statements for debugging
+    public static final double[] MOLAR_MASSES = {135.128, 111.103, 151.128, 125.107, 100.00};
+    public static final char[] NUCLEOTIDES = {'A', 'T', 'G', 'C', '-'};
+
+    /*
+    *
+    * begins with an introduction and prompts for input and output file names.
+    * reads the input file to process its nucleotide sequences.
+    * outputs the results into the given output file.
+    *
+    * @return void
+    *
+    */
+    public static void main(String[] args) throws FileNotFoundException {
+        Scanner console = new Scanner(System.in);
+        String[] files = promptForFileNames(console);
+        File inFile = new File(INPUT_DIR + files[0]);
+        File outFile = new File(OUTPUT_DIR + files[1]);
+        if( inFile.canRead() && inFile.exists() ) {
+            Scanner input = new Scanner(inFile);
+
+            int sequenceCount = linesInFile(inFile) / 2;
+
+            String[] sequences = new String[sequenceCount];
+            String[] sequenceNames = new String[sequenceCount];
+
+            int lineCount = 1;
+            int sequenceIndex = 0;
+            while( input.hasNextLine() ) {
+                String line = input.nextLine(); 
+                if ( lineCount % 2 == 0 ) {
+                    sequences[sequenceIndex] = line.toUpperCase();
+                    sequenceIndex++;
+                }
+                else {
+                    sequenceNames[sequenceIndex] = line;
+                }
+                lineCount++;
+            }
+            
+            PrintStream output = new PrintStream(outFile);
+            saveOutput(sequences, sequenceNames, output);
+            //output = System.out;
+            //saveOutput(sequences, sequenceNames, output);
+        }
+    }
+
+    /*
+    *
+    * Saves output to file using PrintStream as described in Section 6.4 of the textbook.
+    * overwrites any existing data in the output file (this is the default PrintStream behavior).
+    * nucleotide sequence is output in uppercase
+    * the nucleotide counts and mass percentages are shown in A, C, G, T order.
+    *
+    * @params   path    String path of output filename
+    * @return   void;
+    *
+    */
+    public static void saveOutput(String[] sequences, String[] names, PrintStream output) {
+
+        for( int i = 0; i < sequences.length; i++) {
+            output.print("Region Name: ");
+            output.println(names[i]);
+            output.print("Nucleotides: ");
+            output.println(sequences[i]);
+            output.print("Nuc. Counts: ");
+            output.println(Arrays.toString(nucleotideCountFromSequence(sequences[i])));
+            output.print("Total Mass%: ");
+            output.print(Arrays.toString(nucleotideMassPercentFromSequence(sequences[i])));
+            output.println(" of "  + totalMassFromSequence(sequences[i]));
+            output.print("Codons List: ");
+            output.println(Arrays.toString(codonsFromSequence(sequences[i])));
+            output.print("Is Protein?: ");
+            if(isProtein(sequences[i])) {
+                output.println("YES");
+            }
+            else {
+                output.println("NO");
+            }
+            output.println();
+        }
+    }
+    // return boolean test for protein sequence
+    public static boolean isProtein(String sequence) {
+        double[] masses = nucleotideMassPercentFromSequence(sequence);
+        if(masses[nucleotideIndexFromChar('G')] + masses[nucleotideIndexFromChar('C')] <= 30 )
+        {
+            return false;
+        }
+        String[] codons = codonsFromSequence(sequence);
+        if( ! codons[0].equals("ATG"))
+        {
+            return false;
+        }
+        if(! codons[codons.length - 1].equals("TAA") && ! codons[codons.length - 1].equals("TAG") && ! codons[codons.length - 1].equals("TGA"))
+        {
+            return false;
+        }
+        if(codons.length < 5)
+        {
+            return false;
+        }
+        return true;
+    }
+    // non junk masses from sequence
+    public static double[] nucleotideMassesFromSequence(String sequence) {
+        double[] masses = new double[4];
+        int[] counts = nucleotideCountFromSequence(sequence);
+        DecimalFormat df = new DecimalFormat("#.##");      
+        for(int i = 0; i < masses.length; i++) {
+           masses[i] = Double.valueOf(df.format(counts[i] * MOLAR_MASSES[i]));
+        }
+        return masses;
+    }
+    // non junk mass percentages from sequence
+    public static double[] nucleotideMassPercentFromSequence(String sequence) {
+        double[] masses = nucleotideMassesFromSequence(sequence);
+        double total = totalMassFromSequence(sequence);
+        double[] percentages = new double[4];
+        DecimalFormat df = new DecimalFormat("#.##");      
+        for(int i = 0; i < percentages.length; i++) {
+            percentages[i] = Double.valueOf(df.format(masses[i] / total * 100));
+        }
+        return percentages;
+    }
+    // all mass of sequence, junk too
+    public static double totalMassFromSequence(String sequence) {
+        DecimalFormat df = new DecimalFormat("#.#");      
+        double total = 0.0;
+        
+        double[] masses = new double[MOLAR_MASSES.length];
+        int[] counts = new int[MOLAR_MASSES.length];
+        for(int i = 0; i < counts.length; i++) {
+           counts[i] = nucleotideCount(sequence, NUCLEOTIDES[i]);
+        }
+        for(int i = 0; i < masses.length; i++) {
+           masses[i] = Double.valueOf(df.format(counts[i] * MOLAR_MASSES[i]));
+        }
+        for(int i = 0; i < masses.length; i++) {
+            total += masses[i];
+        }
+        return Double.valueOf(df.format(total));
+    }
+    // count of char nulceotide in sequence
+    public static int nucleotideCount(String sequence, char nucleotide) {
+        int count = 0;
+        for(int i = 0; i < sequence.length(); i++) {
+            if( sequence.charAt(i) == nucleotide) {
+                count++;
+            }
+        }
+        return count;
+    }
+    
+    /*
+    *
+    * Converts char nucleotide to molar mass
+    *
+    * mass percentages, use the following as the mass of each nucleotide (grams/mol).
+    * "junk" regions are excluded from many parts of your computations, but they do contribute mass to the total.
+    * Adenine (A): 135.128
+    * Cytosine (C): 111.103
+    * Guanine (G): 151.128
+    * Thymine (T): 125.107
+    * Junk (-): 100.000
+    *
+    * @params   nucleotide  char of nucleotide.
+    * @return   molarMass   rounded to nearest tenth.
+    *
+    */
+    public static double nucleotideToMolarMass(char nucleotide) {
+        return MOLAR_MASSES[nucleotideIndexFromChar(nucleotide)];
+    }
+
+    /*
+    *
+    * pass over a nucleotide sequence and count the number of As, Cs, Gs, and Ts.
+    * uses a String.charAt to get individual characters.
+    *
+    * @params   sequence    sequence of 
+    * @return   counts    array of size 4.
+    *
+    */
+    public static int[] nucleotideCountFromSequence(String sequence) {
+        
+        int[] counts = new int[4];
+        for(int i = 0; i < sequence.length(); i++) {
+            counts[nucleotideIndexFromChar(sequence.charAt(i))]++;
+        }
+        return counts;
+
+    }
+
+    /*
+    *
+    * converts a single character (i.e. A, C, T, G) into indices (i.e. 0 to 3).
+    * includes junk character
+    *
+    * @params   nucleotide  char of nucleotide.
+    * @return   index   int mapping of nucleotide.
+    *
+    */
+    public static int nucleotideIndexFromChar(char nucleotide) {
+        int index = 0;
+        if(nucleotide == 'a' || nucleotide =='A') {
+            index = 0;
+        }
+        if(nucleotide == 'c' || nucleotide =='C') {
+            index = 1;
+        }
+        if(nucleotide == 'g' || nucleotide =='G') {
+            index = 2;
+        }
+        if(nucleotide == 't' || nucleotide =='T') {
+            index = 3;
+        }
+        if(nucleotide == '-') {
+            index = 4;
+        }
+        return index;
+    }
+
+    /*
+    *
+    * eliminate these characters.
+    *
+    * @params   sequence    raw sequence
+    * @return   sequence    without junk DNA '-'.
+    *
+    */
+    public static String removeJunk(String sequence) {
+        String newSequence = "";
+        for(int i = 0; i < sequence.length(); i++) {
+            if(sequence.charAt(i) != '-') {
+                newSequence += sequence.charAt(i);
+            }
+        }
+        return newSequence;
+
+    }
+
+    /*
+    *
+    * break apart the sequence into codons and examine each codon.
+    *
+    * @params   sequence    String of nucleotides or raw.
+    * @return   codons  Array of strings of codons.
+    *
+    */
+    public static String[] codonsFromSequence(String sequence) {
+        int count = sequence.length() / CODONS_PER_NUCLEOTIDE;
+        String[] codons = new String[count];
+        //String[] codons = new String[sequence.length / CODONS_PER_NUCLEOTIDE + 1];
+        String current = "";
+        int index = 0;
+        for(int i = 0; i < sequence.length(); i++) {
+            current += sequence.charAt(i);
+            if((i + 1) % CODONS_PER_NUCLEOTIDE == 0 ) {
+                codons[index] = current;
+            index++;
+                current = ""; 
+            }
+        }
+        return codons;
+
+    }
+
+    /*
+    *
+    * assumes the user will type the name of an existing input file.
+    * input is in the proper format.
+    *
+    * @params   console 
+    * @return   files   array of input and output files for processing and saving
+    *
+    */
+    public static String[] promptForFileNames(Scanner console) {
+        System.out.println("This program reports information about DNA");
+        System.out.println("nucleotide sequences that may encode");
+        System.out.println("proteins.");
+
+        if(DEBUG == true) {
+            String[] files = {"dna.txt", "dna.txt"};
+            return files;
+        }
+
+        System.out.print("Input file name? ");
+        String[] files = new String[2];
+        files[0] = console.nextLine();
+        while( ! validFilename(files[0]) ) {
+            System.out.print("Input file name? ");
+            files[0] = console.nextLine();
+        }
+        System.out.print("Output file name? ");
+        files[1] = console.nextLine();
+        while( ! validFilename(files[1]) ) {
+            System.out.println("Invalid. Try again.");
+            System.out.print("Output file name?");
+            files[1] = console.nextLine();
+        }
+        System.out.println();
+        return files;
+
+    }
+    //count of lines in file
+    public static int linesInFile(File file) throws FileNotFoundException {
+        int count = 1;
+        Scanner input = new Scanner(file);
+        while( input.hasNextLine() ) {
+            String line = input.nextLine(); 
+            count++;
+        }
+        return count;
+    }
+
+    //all files are valid
+    public static boolean validFilename(String name) {
+        return true;
+    }
+}

src/main/java/com/matthewjensen/project/modules/dna/README.md

@@ -0,0 +1,214 @@
+# Topics:
+DNA.java focuses on arrays and file/text processing.
+DNA requires the two input files dna.txt and ecoli.txt.
+These files are saved in the spec/ folder. This can be changed with INPUT\_PATH.
+DNA processes input files, parses the genomic information, and save the output in a new file.
+
+## Learning Outcomes:
+
+
+#Background
+DNA consists of long chains of chemical compounds called nucleotides.
+Four nucleotides are present in DNA: Adenine (A), Cytosine (C), Guanine (G), and Thymine (T).
+This are organized into subunits called "codons".
+Most genes contain condons for building proteins, some do not.
+Each codon (e.g. TAC GGA) uniquely encodes a single amino acid, a building block of proteins.
+The sequences of DNA that encode proteins occur between a start codon (which we will assume to be ATG) and a stop codon (which is any of TAA, TAG, or TGA).
+Not all regions of DNA are genes; large portions that do not lie between a
+Start: ATG.
+Stop: TAA, TAG, TGA.
+Often high percentages of Cytosine (C) and Guanine (G) are indicators of important genetic data.
+
+
+#Input
+- The DNA input data consists of line pairs. 
+- The input file exists, is readable, and contains valid input.
+- The first line has the name of the nucleotide sequence.
+- The second is the nucleotide sequence itself.
+- Each character in a sequence of nucleotides will be A, C, G, T, or a dash character, "-", either upper or lowercase.
+- You may assume that each sequence's number of nucleotides (without dashes) will be a multiple of 3,
+
+##Example
+
+> cure for cancer protein
+> ATGCCACTATGGTAG
+> captain picard hair growth protein
+> ATgCCAACATGgATGCCcGATAtGGATTgA
+> bogus protein
+> CCATt-AATgATCa-CAGTt
+> ...
+
+#Process:
+- from the original nucleotide sequence string to nucleotide counts.
+- from nucleotide counts to mass percentages.
+- from the original nucleotide sequence string to codon triplets.
+
+#Output:
+
+For each nucleotide sequence:
+- nucleotide counts
+    - Counts the occurrences of each of the four nucleotides ['A', 'C', 'G', 'T'].
+- mass percentages
+    - Calculates the mass percentage occupied by each nucleotide type, rounded to one digit past the decimal point.
+- codons 
+    - Reports the codons (TAG) present in each sequence and 
+- protein-coding gene
+    - begins with a valid start codon ["ATG"]
+    - ends with a valid stop codon ["TAA", "TAG", or "TGA")
+    - contains at least 5 total codons (including its initial start codon and final stop codon)
+    - Cytosine (C) and Guanine (G) combined account for at least 30% of its total mass
+
+##Example
+
+> This program reports information about DNA
+> nucleotide sequences that may encode
+> proteins. Input file name? dna.txt
+> Output file name? output.txt
+> Output file output.txt after above execution (partial):
+> Region Name: cure for cancer protein
+> Nucleotides: ATGCCACTATGGTAG
+> Nuc. Counts: [4, 3, 4, 4]
+> Total Mass%: [27.3, 16.8, 30.6, 25.3] of 1978.8
+> Codons List: [ATG, CCA, CTA, TGG, TAG]
+> Is Protein?: YES
+> ...
+
+#Approach
+
+##Constants
+
+```java
+int MIN_CODONS = 5; //the minimum number of codons a valid protein must have
+int MIN_MASS_PERCENT = 30; // the percentage of mass from C and G in order for a protein to be valid
+int UNIQUE_NUCLEOTIDES = 4; // the number of unique nucleotides (representing A, C, G, and T)
+int CODONS_PER_NUCLEAOTIDE = 3; // the number of nucleotides per codon 
+```
+
+```java
+/*
+*
+* begins with an introduction and prompts for input and output file names.
+* reads the input file to process its nucleotide sequences.
+* outputs the results into the given output file.
+*
+* @return void
+*
+*/
+public static void main(String[] args) {
+
+}
+```
+
+```java
+/*
+*
+* assumes the user will type the name of an existing input file.
+* input is in the proper format.
+*
+* @params   console 
+* @return   files   array of input and output files for processing and saving
+*
+*/
+public static String[] promptForFileNames(Scanner console) {
+
+}
+```
+
+
+
+```java
+/*
+*
+* Converts char nucleotide to molar mass
+*
+* mass percentages, use the following as the mass of each nucleotide (grams/mol).
+* "junk" regions are excluded from many parts of your computations, but they do contribute mass to the total.
+* Adenine (A): 135.128
+* Cytosine (C): 111.103
+* Guanine (G): 151.128
+* Thymine (T): 125.107
+* Junk (-): 100.000
+*
+* @params   nucleotide  char of nucleotide.
+* @return   molarMass   rounded to nearest tenth.
+*
+*/
+public static double nucleotideToMolarMass(char nucleotide) {
+    double[] masses = {135.128, 111.103, 151.128, 125.107};
+    double rounded = Math.round(mass * 10.0) / 10.0;
+}
+```
+
+```java
+/*
+*
+* Next, write code to pass over a nucleotide sequence and count the number of As, Cs, Gs, and Ts.
+* use a String's charAt method to get individual characters.
+*
+* @params   sequence    sequence of 
+* @return   counts    array of size 4.
+*
+*/
+public static int[] nucleotideCountFromSequence(String sequence) {
+
+}
+```
+
+```java
+/*
+*
+* converts a single character (i.e. A, C, T, G) into indices (i.e. 0 to 3).
+*
+* @params   nucleotide  char of nucleotide.
+* @return   index   int mapping of nucleotide.
+*
+*/
+public static int nucleotideIndexFromChar(char nucleotide) {
+
+}
+```
+
+```java
+/*
+*
+* eliminate these characters.
+*
+* @params   sequence    raw sequence
+* @return   sequence    without junk DNA '-'.
+*
+*/
+public static String nucleotidesOnlyFromSequence(String sequence) {
+
+}
+```
+
+```java
+/*
+*
+* break apart the sequence into codons and examine each codon.
+*
+* @params   sequence    String of nucleotides or raw.
+* @return   codons  Array of strings of codons.
+*
+*/
+public static String[] codonsFromSequence(String sequence) {
+
+}
+```
+
+```java
+/*
+*
+* Saves output to file using PrintStream as described in Section 6.4 of the textbook.
+* overwrites any existing data in the output file (this is the default PrintStream behavior).
+* nucleotide sequence is output in uppercase
+* the nucleotide counts and mass percentages are shown in A, C, G, T order.
+*
+* @params   path    String path of output filename
+* @return   void;
+*
+*/
+public static void saveOutput(String path) {
+
+}
+```

src/main/java/com/matthewjensen/project/modules/dna/input/dna.txt

@@ -0,0 +1,18 @@
+cure for cancer protein
+ATGCCACTATGGTAG
+captain picard hair growth protein
+ATgCCAACATGgATGCCcGATAtGGATTgA
+bogus protein
+CCATtAATgATCaCAGTt
+michael jordan mad hops protein
+ATgAGATCCgtgatGTGggaTCCTaCTCATTaa
+paris hilton phony protein
+AtgCCaacaTGGATGCCCTAAGATAtgGATTagtgA
+george w bush approval rating protein
+atgataattagttttaatatcagactgtaa
+jimi hendrix guitar talent protein
+ATGCAATTGCTCGATTAG
+tyler durden's brain protein
+ATGATAcctatgagtaaTGTGGACCatatccaaACTATAGGCATtgtcggACCAACGATcgattggtTATACTGA
+mini me growth hormone
+AtGgGaCGCTgA

src/main/java/com/matthewjensen/project/modules/dna/input/ecoli.txt

@@ -0,0 +1,40 @@
+thr operon leader peptide
+ATGAAACGCATTAGCaCCAcCATtACCACCaCCATCaCcATTACCACAGGTAACGGTGCGGGCTGA
+aspartokinase I/homoserine dehydrogenase I
+ATGCGAGtGTTGAAGTTcgGCGGTaCATCAgTGGCAAATGCAGAACGTtTTCTGCGGgTTGCCGATAttCTGGAAAGcAATGCCAGGCAGGGGCAGgTGGcCACCGTCCTCtCTGcCCCCGCCAAAATCACCAACCATCtGGTaGCGATGATtGaaAAaACCATtAGCGGTCAGGAtGCtTTaCcCaATATCAGCGATGCCGAACGTATTTTTGCCGAACTtCTGACgGGACTCGCCGCcGCCCAGcCGGGATTTCCGCTGGCACAAtTgAAAAcTTTCGTCGACCAgGAATTTGCCCAAATAAAACATGTcCtGCATGGCatCAGTTTGTTGGGGCAGTGCCCGGaTAGCATcAACGCTGCGCTGATTTGcCGTGgCGAGAAAaTGTcGaTcgCCattaTGGCCGGCGTGTTAGAAGCGCGTGGTCACAACGTTACCGTTATCGATCCGgTCGAAaAAcTGCTgGCAGTGGGTCATTAcCtCgAaTCTACCGTTGATaTtGCTGAATCCACCCGCCGTATTGCGGCAAGCCGCATTCCgGCTGACCACATgGtGCTGATGGCTGGTTTCACTGcCggTAATGAAAAAGgCGaGCTGGtGGTtCTGGGAcGCAACGGTTCCGACTaCTCCGCTGCGGTgCTGGCGGCcTGTTTaCGCGCCGATTGTTGcGAgaTCTGGACGGATGTTGAcGGTGTTTATACCTGCGATCCGCGTCAGGTGCCCGATGCGAGGTTGTTGAAGTCGATGTCCTATCAGgAaGCGATGGAGCTTTCTTACTTCGGCGCTAAAgTTCTTCaCCCcCGCACCATTACCCCCATcGCCCAGtTCCAGATcCCTtgCCtGATTAAAAATAcCGgAAAtCCCCAAGCACCAGgTACGCtCATTGGTGCCAGCCGTGATGAAGACGAATTACCGGTCAAGGGCATTTCCAATcTGAATaACATGGCAATgTTCAGcGTTTCCGgCCCGGGGAtGAAAGGgATggTTgGCATGGCGGCGCGcgTCTTTGCAGcGaTGTCACGCGCCCGTaTTtCCGTGGTgCtGATTACGCAATCATCTTCCGAATACAGTATCAGTTTCTGCGTTCCGCaAAGCGACTGTGTGCGAGCTgAaCGGGCAaTGcAGGAAGAGtTCTACCTGGAaCTGaAAGAAGGCTTACTGGAGCcGTTGGCgGtGACGGAACGGCTGGCCATTATCTcGGTGgTAGGTGATGGTATGCGcACCTtaCGTGGGAtCTCGgCGAAATtCTtTGCCGCGCTgGCcCGCGCCAATATCAACATTGTCgCCATTGCtCaGGGaTCTTcTGAaCGCTCAAtCTCTGTcGTGGTcAaTAACGATgATGCGACCACTGGCGTGCGCGTTACTCATCAGATGCTGTTCAATACCGATCAGGTTATCGAAGTGTTTGTGATTGgCGTCGGTGGCGTTGgcGGTGCGCTGCTGgAGCAACTGAAGCGTCAgCAAAGCTGGTTGAAGAATAAaCATATCGaCTTACGTGTCTGCGGTGTTGCTAACTCGAAGgCACtgCTCACCAATGTACATGGCCTTAATCTGGAAAACTGGCAGgAAGAACTGGCGCAAGCcAAAGAGCCGTTTAATCTCGgGCGcTtAATTCGCCTCGTGAAAGAATATCATCTGCtGAaCCCGGTCATTgTTGACTgTACTTCCAgCCAGGCTGTgGCAGaTCAATATgCCGACTtCCTgCGCGAAGGTTTCCAcGTTGTtACGCCGAaCAAAaAGGCCaACACCTCGTcgATGGaTTACTaCCATCAGTtGCGTTATGCGGCGGAAAAATCGCGGCGTAaATTCCTCtATGACACcaACGTtGGGGCTGGATTACCGGTTATTgAGAACCTGCAAAATCTGCTCAATGCtGGTGATGAATTGATGAAGTTCTCCGGCATTCTTTCAGGTTCGCTTTCTTAtATCTTCGGCAAGTTAGACGAAGGCaTGAGTtTCTCCGAGgCGACCaCACTGGCGCGGGAAATGgGTTATACCGAACCGGAcCcGCGAGATGATCTTtCtGGTATGgAtGTGGCGCgTAagCTAtTGATtCTCGCTCGTGAAACGGGACGTGAACTGGAGCtGGCGGATATTGAAATTGAACCTgTGCTGCCCGCaGaGTTTAACGCCGAGGGTGATGTCGCcGCTTTTATGGCGAATCTGTCACAGCTCGACGaTCtCTTTGCCGCGCGTGTgGCGAAGGCCCGTGATGAAGGAAAAGTTTTGCGCTATGTTGGCAATAttGATGAAGATgGCgTCTGCCGCGTGAAGaTTGCCGAAGTGGATGgTAATGaTCCGCTGTTCAAAGTGAaAaATGGCGaAAACGCCCTGGCCTTCTATAGCCACTATtATCAGCCGCTGCCGTTGGTACTGCGCGGATATGGTGCGGGCaATgACGTTaCAGCTGCCGGTgTCTTTGCTGATCTGCTACGtACCCTcTCAtGGaAGTTAGGAGTCTGA
+homoserine kinase
+ATgGTTAAAgTTTAtGCCCCGGCtTCCAGTGCCaATATGaGcGTCGgGTTTGATGTGCTCGGGgCGGCGGTGACACCTGTTGATGGTGCATTGCTCGgAGaTGTagTcaCGGTTGAGGCGGCAGAGACaTTCAgTCTCAACAACCTCGGACGCTTTGCCGAtAAGCTGCCGTCAGAGCCACGgGaaAATAtCGTTtATcAGTGcTGGGAGCGTtTTTGcCaGGAGCTTGGCAAGCAAATTCCAGTGGCGATGaCTCTGGAAAAGAATatGCCGAtCgGTTCGGGcTTAGGCTcCAGCGCCtGTTCAGTGGTCGCGGCgCTgAtGGCGATgAATGAAcACTGCGGCaAGCCGCTTAATGACACTCGTTTGCTGGCTTtGATGGgCGAgTTGGAAGGGcGTATCTCCGGCAGCAtTCATTACGACAACGtGGCACCGTGtTtTCtTGGTGGTAtGCAGTtgATGATCGAAGAaAACGACATCATCAGCCAGCAaGTGCCAGGGTTTGATGAGtGGCTGTGGGTGCTGGCGTATcCGGgGAtTAAAGTCtCGaCGGcAGAAGCCAGGGCTaTTTTACCGGCGCAGTATCGCCGCCAGGATTGCATTGCGCAcGGGCgACATCTgGCAGGCTTCATTCACGCCTGCTATTCCCGTCAGCTTGAGCTTGCCGCGAAGCTGATgAAAGaTGTTATCGCTGAACCCTACcGTGaACgGTTaCTGCCAGGCTTCCGGCAGGCGCGGcAGgCGGTTGCGGAAATCGGCGCGGTAgCGAGCGGTATCTCCGGCTCCGGCCCGAcTtTGTTCGCTCTGTGtGAcAAGCCGGATACCGCCCAGCGCGTTGCCGACTGgTTGGGTAAGAACtAcCTGCAAAATCAGgAAGGTTTTGTTcATATTTGCCGGCTGGATACGGCGGGcGCACGAgTACTGGAAAACTAA
+threonine synthase
+ATGAAACTCtacaATCTGAAAGATCACAATGAGCAGgTCaGCTTTGCGCAAGCCGTAACCCAGgGgTTAGGCAAAAATCAGGGgCtGTtTTTTCcgCACgaCCTGCCGGaaTTCAGCcTgACTGAAaTTGATGAGATgCTGAAGCtGGATTTTGTCACcCGCAGTGCGAAGATCCTcTCgGCGTTTATTGGTGATGAAATCCCGCAGGAAaTCCTGGAAGAGCGCGTACGTGCGGCGTTTGCCTTCCCGGCTCCGGTCGCCAATGTTGAAaGCGATGTCGGTtGTCTGGAaTTGTTCcACGGGCcAACGCTGGCaTTTAAAGATTTCGGcGGTcGCTTTATGGCACAAATGCTgACCcATATTGCGGGCGATAAGCCAGTGAcCATTCTGACCGCGACATCCGGTgATACTGGaGCGGCAGTGGcTCATGcTTTCtACGGTtTACCGAATGTGAAAGTGGTTATCCTCTATCCACGAGGCAAAATCAGTCCACTGCAAGAAAAACTgTTCTGTACATTGgGCggCAATATCGaAACTGTTGCCATCGAcggCGaTTTCGATGCCTGTCAGGCGCTGGTgAAGCAGGCgTTTGATGATGAAGAACTGAAAGTGgCgCtGGGGCtGAATTCTGCTAAcTCCATCAACaTCAGTCGCTTGCTGGCGcAGATTTGTTaTTAcTTTGaGGCTGTCGCACAGTtGCCGCAAGAAGCACGTAACCAGTTGgTTGTCTCGGTaCCGAGTGgAAACtTcGGCGATtTGACGGcGGGTCTGCTGGCGAaGTcACTCGGTCtGCCGGTAAAACGTtTTATTGCtgCGACCAACGTGAACGAtACCGTACCACGTTTCCTGCaCGaCGGTCAGTGGTCAcCCAAaGCGACTCAGgCGAcgTtaTCCAATGCGATGGATGTTAGCCAGCcAAaCAACTGGCCGCGTGTGGAAGAGTTGtTCcGCCGCAAAATCTGGCAACTGAAAGAGCTGGgTTATGCAGCCGTGgATGATGAAACCACGCAACAGACAATGcGTGAGtTAAaAGAACTGGGCTATACCTCGgAGCCGCACgCTGCCGTAGCTTATCGTGCGCTGCGTGACCAgTTGAAtCCAGGCGAATATGGCTTGTtCCTCGGcACcGCGCATCcGGcGAAatTtAAAgAGAGCGTGGAAGCGATTCTCGGTGAAAcGTTGGatCTGCCAAAAGAGCTGGCAGAACGTGCTgATTTACCCTTGCTTTCGCATAACCTGCCCGCCGATTTTGCTGCGTTGCGTAAatTgaTGATGAaTCATCAGTAA
+hypothetical protein
+AtGCAGCCcGGCTtTTTTTATGAAGAAAATaTGGAGaAaAACGACagGGAAAAAGGAGAAATTCtCAATAAATGCGGtAACTTAGAgATTaGGATTGCGGAGAATaACAACTGCcGTTCTCaTCGCGTAATCTCCGGATATCGACCCaTAACGGgCAATGATAAAAGgAGTAACCTGTGA
+Non-protein region
+aAAAACTgCTGGAAACAATGAAAGAcGTACCGGACGACCAAcGTCAGgCGC
+transaldolase B
+ATGACGGACAAATTGaCCTCcCTTCGTCAGTACACCACCGTAgTGGCCGACACTGGGGACATCGCGGCAATGAAGcTGTaTCAACcGCAGGATGCCACAACCAAcCCTtCTCTCATTCTTAACGCAGCGCAGATTCcGGAATACCGTAAgTTgATTGaTGATGCTGTCGCCTGGGcGAaACaGCAGAGCAAcGATcGCgCgCAGCAgATCGtGGACGCGACCGAcAAACTGGCAGTAaATATTgGTCTgGAAaTCCTGAAACTGgTTCCGgGCCgTATCTCAActGAAGTtGATGCGCGTCTTTCCTATGACaCCGAAGCGTCAATTGCGAAAGCAAAACGCCTGATCAAACTCTACAACGATGcAGGTaTTAGCAACGATCgTaTTCTGATCAAACTGGCTTCTACCTGGCAGGGTATCCGTGCTGcAGAACAGCTGGAAAAAGAaGGTATTAACTGTAAcCTGACCCTGCTgtTCTCctTCGCtCAGGcTCGTGCTTGTGCGGaAGCGGgCGTgTTCCTGaTCTCGcCGTTTgTTGGCcGTATTCTTGACTGGTAcAAaGCGAATACCGaTAAGAAAGAGtACGCTCcGGCAGAAGATcCGGGCGTGGTTTCTGTatCtGAAATCtACCAGtACTACaAAGAGCATGGTTaTgAAACCGTGGTTATGGGCGCAAGCTTCCGTAACATCGGCGAAATTCTGGAAcTGGCAGGCTGCGACCGTCTGACCatCGCACCGgcACTGCTGAAAGAGCTGgCGGAGAGCGAAGGGGCTATCgAACGTAAACTgTCTTACAcTGgTGAAGTgAAAGCgCGTCCGGcGCGTATCACtGAGtCCGAGTTCCTgTGgCAgCACAACCAGGATCCAATGGCAGTaGATAAACTgGcGGaAGgTATCCGTAAGTTTGCTGTTGACCAGGAAAAACTGGAAAAAATGATCGGCGATCTGCtGTAA
+molybdopterin biosynthesis mog protein
+ATGAATACTTTACGTATTGGCTTaGTtTcCaTCTCTGATCGCGCATCCAGCGGCGTTTAtCAGgaTAAAgGCATCCCTGCGCTGGAagAATGGCTGACAtcGGCGCTAACCACGcCGTTTGAaCTGGAAAcCCgCTTaATCCCCGATGAGCAGGCGATCATCGAGCAaACgTTgTGTGAGCTGGTGGATGAAaTGAGtTGCCaTCTGGTGCTCACCACGGGCGGAAcTGGCCCTGCGCGTCGTGAcgTAACGCcCGATGcGACGCTGGCAGTAGCGGACCGCGAGATgCcAGGCTTTGGTGAACAGATGCGCCAGATCAGCCTGCATTTTGTACcaaCTGCGATCCTTTCGCGTCAGGTggGGGTgATTCGCAAACAGGCGCTGATCCTTAACTTaCcCGGTCAACCGAAGtCTATTAAAGAGACGCtGgAAGGTGtGAAGGACGCTGAGgGTAAcGTTGTGGTGCACGgTATTTTTGCCaGCGTaCcGTaCTGCATTCAGTTGCTGGAAGGGCCATACGTTGAaACGGCaCCgGaAGTGGTTGCAGCATTCAGaCCGAAGAGTGCAaGACGCGAAGtTAGCGAATAA
+chaperone protein DnaK
+aTGGGTAAAATAaTTGGTATCGACcTGGGTACtACCAaCTCTTGTGTagCGaTTAtGGATGGCACCACTCCtCGTGtACTGgAGAACGcCGAAGGCGATCGCACCAcGcCTTcTATCATTgCCTATACCCAGGAtGGTGAAACTCTGGTTgGTCAGCCGGCTAAACGTCAGGCAgtGACGAACCCgCAaAACAcCCTGTtTGCGATTAAACGCCtGATTGGCCGCCgCTTCCAGgACgAAGAAGTACAGCGtGATgTTTcCATCATGCCGTTCAAAATTAtTGcTGCtgatAACGGCGACGcATGGGTCGAAGtTAAAgGCCAGAAAATGGCAcCGCCGcAGAtCTCTGCTGAAGTGCTGAAAAAAAtGAAGAAAACCGCTGAAGaTTAcCTGGgTGAAcCGGTAACTGaAGCTgtTATTACCGTACCGGCAtACTttaACGATGCTCAGCGTCAGGcAACCAAAGaCGCAGGCCGTATCGCTGGTCTGGAAGTAAAaCGTATCATCAACGAaCCGACCGCAGCTGCGCTGGCTtACGGtCTGGACAAAGgTACTGGCAACCgtACTATCGCGGTTTATGACCTGGGTGGTGGTACTTTCGATATTTcCATTATCGAaATCGACGAAGTTGACGGCgAAAAAACCttCGAAGTTCTGGCAACCAACGGTGATACCCACCTGgGTGGtgAAGACTTCGACAGTCGTCTGATCAACTAtCTGGTTGAaGAATTCAAgAAAGATCAGGGCATTGacCtGCGCAACGaTcCGCTGGCAATGCAGCGCCTGAAaGAAGCGGCAGAAAAAGCgAAAATCGAACTGTctTCCGCTCAGcAGACCGaCGTTAACcTGCCGTACATCACTGCAGACGCGAcCGGTCCGAAACACAtGAACATCaAAgTGactCGTGCGAAACTGGAAAGCCTgGtTGAAGAtCTGGTAAACCGtTcCATTGAGCCGCTGAAAGTTGCACTGCAGGACGCTGGCCTGTCCGTATCTGATAtCGACgaCGTTATTCTCGTTGGTGGTCAGACTCGTATGCcAATGGtTCAGAAGAAAGTTGCTGaATTCTTTGGTAAAgAGCcGCGTAAAGATGTTAACCCGGACGAAGCTGTaGCCATCGgTGCTGCTGTTCAGGGTGGTGTTCTGACTGGtGAcGTAAAAGaCGTacTGCTgCtGGACGTTACCCCGCTGTCtCTGGGTATcGaAACCaTGGGCGGTGTGATGACCACGCTGATCGCgAaAAACACCACTATCCCGACCAaGcAcaGCCAGGTGTTCTCTACCGCTGAAGACAACCAGTCTGCGGTAACCATcCATgtGCTGcAGGGTGAACgTAaACGTGCgGCTGAtAAcaAATCTCTgggTCAGTTcAACCTGGATGGTATCAaCCCGGCACCGcGCGGCAtgCCGcAGATCGAAGtTACCtTCGAtATCGaTGCTGACGGTATCCTGCaCGTTTCCGCGAAAGACAAAAACAGCGGTAAAGAGCAGAAGATCAcTATCAaGGCTTCTTCTGGtCTGAaCGAAGAtGAAATCCAGAAAATGGTACGCGaCGCAGAAGCTAAcGCCGAAGCTGACCGTAaGTTTGAAGAGCTGGTACAGACtcGCaACCAGGGCGACCATCTGCTGCACAgCACCCGTAAGCAgGTTGAAGAAGCAGGCGACAaACTGCCGGCTGACGACAAAACTGCTATCGAGTCTGCGCTGActGCACTgGAAACtGCTCTGAAaGGTGAAGaCAAAGcCgCTATcGAAGCGAAAATGCAGGAACTGGCACAGGTTTCCCAGAAACTGATGGAAATCGCCCaGCAGCAACATGCcCAGCAGCAGACTGCCGGTGCTgATgCTTCtGCAAaCAAcGCGAAAGaTGACGATGTTGTCGACGCtGAATTTGAAGAAGTCAAAGACAAAAAATAA
+chaperone protein DnaJ
+GTGCatTCatCTAGGGGcAATTTAAAAAAGATGGCTAAGCAAGATTaTTACGAGaTTTTAGGCGTTTCCAAAaCAGCGGAAGAGCGtGAaaTCAAAAaGGCCTACAAACGCCTGGCCATGAAaTACCaCCCGGaCcGTAACCAGGgTGACAAAGaGGCCGAGGCGAAATTTAAAGAGATCAAGGaAGCTTATGAAGTTCTGACCGACtCGCAAAAACgTGCgGCATaCGATCAGTaTGGTCATGCTGCGTTTGAGCAAGGTGGCATGGGCGGCGGcGGtTTTGGCGGCGGCgCAGACTTcAGCGATAtTTtTGGTGACGtTTTCGGCgATATTTTTGGcGGCGGACGTGGTCGTCAACGTGCGGCGCGCGGTGCTGATTTAcGCTATAACATGGAGctCACcCtCGAAgAAGCTGTACGtgGCGtGaCCAAAGaGATccGCATtCCGACTCtGGAAGAGTGTGACGTTTGCCACgGTAGCgGTGCAAAACCaGGTACACAgCCgCAGACCTGTCCGACcTgTcATGGTTCTGGCCAGGtGCAGATGcGCCAGGGTTTCTTTGcCGTGCAGCAGACCTgTCcAcACTGTCAGGGCCGCGGTACGCTGaTcAAAGATCCGTGCAACAAATGTCATGGTCATGGTCGTGtTGAGCgCaGCAAAACGCTGTCCGTTAAAATCCCGGCaGGGgTGGACACTGGAGaCCGCATCCGTCTTGCGgGCGAAGGTGAAGCGGGTGAACACGgCGCACCGGCAGGCGATCTgTACGTTCAGGTtCAGGTtAAACaGCACCCGATTTTCGAGCGTGAAGGCAACAACCTGTATTGcGAAGTcCCGATCAAcTTCGCTATGgCGGCGcTGGGTGGTgaAATCGAAGTACcGACCcTTGATGGTcGcGTCaaACTGAAAGTGCCTGGCGAAACCCAGACCGGTAAgCTGtTCCgTaTGCGCGGTAAAGGCGTCAAGTCtGTcCGCGGTGGcgCACAGGGTGATTtGCTATGCCGCGTTGTTGTCgaAACAcCGGTAGGTTTGAACgAGAAGCAGAAACAGCTGCTGCAAGaGctGCAAGAAAGCtTTGGTGGcCCAACCGGCGAGCACAACAGCCCGCGTTCAAAGAGCtTCTTtGATGGCGTGAaGAAGTTTTTTGACGaCCTgACTCGCTAA
+hypothetical protein
+TTGCTCTTaCTCGGATTCgTAAGCCGTGAAAACAGCAaCCTCCGtCTGGCCAGTTCGGATGTGAACCTCACAGAGgTCTTTTCTCGTTACCAgCGCCGCCACTACGGCGGTgATACAGATGACGATCAGgGcgACaAtcAtCgCcTTATGCTGCTTCATTGCTCtCTtCTCCTTGACCTTTCGGTCaGTAAGAgGCACTCTACATGTGTTCTGCATATAGgGGGCCTCGgGTtGATGgTAAAATAtCACTCGGGGCTTTTCTCTAtCTGCCGTTCAGCTAATgCcTGA
+hypothetical protein
+aTGTCTGCCAAaaGACGACTTCTTATTGCGtGTACCTTGAtAaCAGCTATcTATCAtTTTCCTGcaTATTCTTCATTAgAATATAAAGGAtCCTTTGGTTCAATaAATGCGGGTTAtGCAGACTGGAATAGTGGaTTTgTAAaCACTCACCGTGGTGAaGTATGGAAAGTGACtGCGGATTTTGGGgTaAATTTTAAAGAAGCAGAATTTTACTCAtTTTATgAaAGTAATGTACTCAATCATGCTGTAGCAGGGAGAAATCATACgGtTTCAGCAATGaCGCATGTCAGACTCtTTGaCtCTGATaTGACATTCTTTGGCAAAATTTaTGgCCAATGGGATAACTCATgGggTGAcGATCTgGACATGTTTTATGGATTCGGTTACCTCGGCTGGAACGGCgAgTGGgGCTTTTtTAAACCGTATATTGGATtGCATAATCAATCTGGTGACTACGTATCAGCTAAATaTgGTCAAACGAATgGTTgGAATGGtTATGTTGTTGGCTGGACAGCAgTATTAcCATTTAcGTTATTTGACGAAAAATTTGTTTTATCTAACTGGAATGaAATAGAACTGGACAGGaACGATGCTTACACGgAgCAGcAATTTGGCcGGAACGGgTTaAaTGGCGGtTTAACTATTGcCTGGAAGTTCTATCCTCGCTGGAAAGCCAGtGTGACGTGGCGTTATTTcGATAAtAaGCTGGGCTACGATGGCTTTgGcgaTCAAATGATTTAtATGCTTGgTTATGATTTCtAA
+putative secreted sulfatase
+ATGCAGAAAACGTTAATGGCCAGTTTGATCGGCCTTGCAGTTTGCACAGGGAAtGCTTTTAGtCCTGCCTTAGCCGCAGAGGCTaAACAACcTAATTTAGTCATtaTTATGGCGGaTGATtTAGGTtaTGGCGAtTTAGcAaCaTATGGTCATCAGATCGTTAAAACACctAATATCGACAGGCtTGCCCAgGAAGGGGTCaAATTtACTGAcTaCTATGCCCCCGCTCCTTtAaGTTCAccTtCACGCGCaGGGCTATTAACCGGCcGGATGCCATTtCGTAcTGGAATTCGCTCATGGATtCCttCAGGCAAAGATGTTGCCtTAGGGCGTAACGAAcTCACgATTGCTAaTCTACTCAaAgCGCAaGGGTACGACACggCAATGATGGGTAAGCTGCATCTGAATgCAGGcGGCGaTCGCACCGATCAgCCaCAAGCACaAgATATGGGcTTTGATTAcTCAcTGGTtAATACgGCGGGCTTTGTTACcGACGCCACGCTGGATAAcGCTAAAGAACGCCcGCGTTATGGCATGGTTtAccCGACAGGCtgGCtACGTAACGGGCAACCCACTcCACGaGCTGATAAAAtGAGCGGTGAGTATGTCaGTTCGGAAGTCGTCAACTGGCTGGATAACAAAaaGGACaGCAAGCCTTTCTTCCTCTATgTTGCTTTTACCGAAGTGCATAGCCCCCTGGCTTCGCCCAAAaaATACCTCGATaTGTaCTCACaATATATGAGCGCGTATCAGAAGCAGcATCCTGATTTAtTTTaTGGCGACTGGGcAgACAAACCCTgGCGTgGTGTGGGgGAATATTAtGCCAATATCAGCTATCtGGATGCAcAGGTTGGAAAAgTGCTGGaTAAAATCAAAGCTGTGGgtGaAGaaGaTAACACAATCGTTATTTTTACCAGTGatAACGGTCCgGTAaCGCGTGAAGCGCGCAAAGTGTATgAGCTGAATTTGGCAGGGGAaACGGaTGGATTACGCGGTCGCAAGGATAACCTTTGGGAAGGCGGAATTCGtGTTCCaGCCATTATTAAATaTGGTAAACATCTACCACAGGGAATGGTTTCAGATACACCCGTTTATGGtCTgGACTGGATGCCTACtTTaGCgAaAATGATGAACTTCAAATTACCTACAGAcCGTAcTTTCGATGgTGAATCGCTGGTTCCTGtTcTTGAGCaAAAAGCATTGAAACGCGAAAAGCCATTAATTTTCGGGATTGATATGCCATTCCAGGATgATCCAAcCGATGAATGGGCGATCCGTGATGgTGACTGGAAgAtGATTATCGATCGcaATAATAAACcGAAATATCTCTACAATCTGAAATCTGATCGTTATGAAaCaCTTaAtCTGATCGGTAAAAAAACAgATATTGAAAAACAGATGTATGGTaAGtTTtTAAAATATAAAACTGATATTGATaATGATtCTCTAATGAAAgCCAGAGGTGATAAACCAGAAGCGGTGACCTggGGCTAa
+putative cytoplasmic protein
+ATGTTTACcAacGTAAATGTTGATTGtTgCAAAACACCAGGAtGTAAaaACCTGGGGTTGCTGAATAGCCAGGATTATGTCGCAcAGgGTaAaAATATTTtATGCCGTGAATGTgGTTaCTTGTtTCCAGtGATATCTGAACAGTCGCTTAAtATTTaTCGTAATATTGTGAAtcACTcCTGGAGAGGTTTGATTTGCCAATGTTCAACTtGCGGAGGcACGTCCCTCAAAAAATaTGgATATtCtGCAcAagGCCAgAGAAGAATgTATTGCcaTCAtTGTGaGAAAACaTTtATCACTCTGGAAcAtGTAATTACcACACCACGAGGAGCcCTGTTAGcATTGATGATTGAGCAAGGGGAGGCACTTGCGGaTATCAgAAAGTCATTACGTCTTAACAgCACTGGACTTAGCCGTGAACTGTTAAAATTAGCGCGTGAAGcAAACTATAAAGAAAGTCGACAGTGTTTCCCTGCTTCTGATATTACCCTGAGtACCCGCGCTTtTCGcgTCAAGTAtAATGGTAGCAATAACTCTCTTTATGCTCTTGTTACCGCAGAAGAACAAAGcGGCAGGGTgGTTGcCaTCTCAACCAATTACTCCCCATCtGCCGTAGagCaaCATTATcAATACaCATCGAACtATGAAGAGcGTATGTCTCCAGGGACGCTGGCACAtCATGTCCAGCGCAAAGAGttACTTACTATGCGGCgGGATACCTTGTTTGATATTGATTACGGCcCGgCAGTTTTACATCAAAACGATCCGGGAATGtTGGTAaAaCCGGTTCTTCCGGCATaTCGTCATTTTgAACTGGTCAGAATACTGACCGATGAGCATtCCAACAACGTTCAGCATTACCTTGATCACGAATGCTTTATaTTGGGCGGCTGcCTGATGGCTAATTTGCAGCaTATTCATCAaGGTCGCTGCCATATTTCcTTTGTCAAaGAGCGcGGTGTGGCACCCGCCACCATTGaTTTTCCACCGCGATtATTCcTTAGTgGtGGgGTACgAAATAATGTCTGGCGTGCaTTTTCTAACCGCAATTATTCAaTGGCTGTATGCAAtCTCaCTGGCAGTAAGAAAGTCCGCGAGATGCGGCATGCAACATtGAACAGTGCGACGCgTTtTATCCACTTTGTGgaGAACCATCCTTTCCTTATaTCATTGAACCGAATgtCTCCTGCGaaTGTCgtTTCTACaTTAGATaTCCTCAAACaTCTGTGGAATAaAaAACTAGagCATGGAACAATTtAA
+sodium/proton antiporter 1
+GTGAAACATCTGcATCGATTCTTTAGCaGTGATGCCTCGGGAGgCATTATTCTCATTATTGCCGCTGTATTAGCGATGATTATGGCCAACAGCGGTgcAaCCAGTGGATGGTATCACGACTTTCTTGAGACGCcGGTTCAGcTcCGGGTTGGGACACTTGAGATCAACAAGAACATGCTGCTATGGATCAATGaCGCTCTGaTgGCGGTATTTTTCCTGTtGGTTGGTcTGGaAGTTAAAcGCGAGcTGaTGCAaGGTTCGCTGGCCAGTCtGCgCCAGGCGGCatTTCCTGTTATTGCCGcAATCGGCGGGATGATTGTCCCGGCATTGCTCTATCTGGCTtTtAACTATGCCGATCCGaTTaCCCGCGAAGGcTGGGCAatCCCGGCGGCGACTGacATTGCCTTTGCACTTggTgTGTTGGCGCTgTTGGGAAGTCGTGTTCCGTTAGCGCtGAAGATCTTTTtGATGGCTCTGGCtATTATCGACGATCTTgGGGcCATCATtATCATCGCATTGTTCTACAcTAATGACTTATCGATGGCCTcTCTTGGCGTcGCgGCTGTAGCAATTGCGgtACTCGCGGTATTGAAtCTGTgTGGTGTAcGCCGCACGGGCGTtTATATTCTGGTTGGCGTGGTGCtGTGGaCAGCGGTGTTGAAATCGGGGGTTCACGCAACCcTGGCTGGCGtCATtGtCGGCTTCTTTATTCCTTTGAAAGAGAAGCATGGgCGCTCTCcGgCTAAACGTCTGGAGCATGTTTTGCAtCCATGGGTGGCGTATCTGATtTTGCCGCTGTTTGCATTTGCTAATGCTGGCGTTTCACTGCAaGGTgTCACGCtggAaGGTTTgACCtCCATTCTGCCATTAGgGATCATCGCTGGTTTGCTGaTTGGCaAGCCACtGGGTAtTaGTCTgttcTGCTGGtTGGcgCTGCGTTTGAAATTGGCACATCTGCCAGAGGGAACgACTtACCAGCAAATTATGGCGGtTGGTaTCcTGTGCGgTATCgGTTtTAcTatGTCTATCTTTATTGCCAGCCTGGcATTTGGTAgCGTAGATcCAGAaCTGaTTAACtGGGCAAAAtTAgGTATCCTTGTCGGTTCAATTTCtTcGgCGGTAATTGGATATAGcTGGTTACGcGTTCGTTTACGTCcATcAGTTTGA
+transcriptional activator protein NhaR
+ATGAGCATGTCTCATaTCAATTACAACCACTtGTATTACTTCTGGCaTGTCTAcAAAgAaGGTTCTGtGGTTGGCgCAGCGGAGGCGCTTTATTTAACAcCAcAAACCATTACCGGGCaGATCCGGGCGCTGGAaGAGCGCCTGCAAGGGAAAcTATTTAAGCGTAAAGGAcgTGGTCTGGAACCCAgcGAACTGGGGGAACTGGTCTATCGCtATGCCGATAAAATGTTCAcCTTAAgCCAGGAAATGCTgGATATCGTCAACTATCGCAAAGAGTCCAACTtATTGtTTGATGTTgGTGTGGCAGATGCACTTtcCAAAcGtcTGGTCAGCAGTGTTCtgGATgCCGCAGTtgTGGAAGACGAGCAGAtCCATCTACGCTGTTTCGAaTCGACGCACGAGATgCTTTTaGAGCAgtTGAGTCAGCATAaACTGGATATGATcaTCTCTGACTGTCCGaTCGATTCCACTCAGCAGGAAGGGCTGTTTTCCATGAAAaTtGGCGAATGTGGTGTCAgtTTCTGGTgCACTAACCCACTACcAGAAAAGCCGTTTCCTGCCtGTCTTGAAgAGCgTCGtTtACTTATTCCGGGGCGTCGCTCAaTgTTGGGGCGtAAACTATTAAACTGGTTTAACTCcCAGGGCTTGAACGTCGAAATTTTGgGTGAGTTTGATGATGCTGCGTTGATGAAAgCCTTTGGGGCGAcGCATAACGcTATTTTCGTTGCACCTTCGCtTTACGCTAATgATTTCTATAACgATGACTCGgTtGTGgAGATAGgCCGTGTTGAGaACGTGATGGAAGAGTACCACGCGATTTtTGCCGaAAGgaTGAtTCAgCACCCTGcAGTAcAGCGTATCTGcAATACAgacTATTCTGCGCtgTTTACTCCAGCTTcAAAATAA
+riboflavin kinase
+ATGAAGCTGATACGCGgCAtACATAATCTCAGCCAGGCCCCGCAAGAAGGGTGTGTGCTGACTATTGGTaATTTCGACGGCGTGCATCGCggTCATCGCGCGCTGTTACAGGGCtTGCAGGAAGAAGGGCGCAAGCGCAACtTACCGGTGATGGTGATGCTTTTtGaACCTCAACCAcTGGAACTGTTTGCTACTGAtAAAGCcCCGGCACGGcTcACcCGGCTGCgGGAAAAACTGCgTtaTcTTgCAGAgTGTGGCGTTGATTACGTGCTGTGCGtGCGTtTTGaCaGGCGTtTTGCGGCGTTAACCGCGcAAAACTTCATCAgTGATCTtCTGGTGAAGCACTTGCGGGTAAAATTTCTTGCCGTAGGTGACGAtTTCCGCTTTggCGCTGgTCGTGAAgGCGAtTTCTtGTTATTACAGAaAGcgGGCATGGAATACGGCTTCGATATcACCAGCaCGCAAAcTTtTTGCGAAGGTGGTGTGCGtATCAGcAGCACCGCCGtgCGTCAGGCGCtTGCGgATgACAATCTGGCTCTGGCAGAAAGTTTACTGGgGCACCCGTTTGCTATCTCCGGGCGTGTAGTCCACGGTGATGaATTAGGGCGCAcTATAGGTTTCCCgACGGCGaATGTACCGcTaCgCCGTCAGGTTTCCCCGGTGAAAgGGGTTTATGCGGTAGaAgTgTTGGgCCtTGgCGAAaAGcCGTTAcCCGGcgTTGCAAACaTCGGAACACgCCCAACGGTTGCcGGTATTCGCCAGCAACTGgaAGTGCATTTGTTAGATGTTGcAATGGaCCTTTATGGTCGCCAtATACAAGTAGTGCTGCGtAAAAaAATAcGCAATGAGCAgCGATTTGcATCGCTGGACGAACTGAAAGCGCAGATTGCGCGTGATGAATTAACCGcCCGCGaaTTTtTTGGGCTAAcAAAACCGGCTTAa
+Isoleucyl-tRNA synthetase
+ATGAGTGACTATAAATCaACCCTgAATTTGCCgGAAACAGgGTtCCCGATgCGTGGCGATCTCGcCAAGCGCGAAcCGGGaATGCTGGCGCGTTGGACTGATGATGATCTgTaCGGCATCATCCGTGCGGCTaAAAAAGGCAaAaAAACCTTCAtTCTGCATgATGGCCcTCCTTATGCGAATGGCAGCAtTCaTATTGGTcACTCGGTTAACAAGATTCTGAAAGACATTaTCATTaAgTCCAAAgGGCTttCTGGATATGACTCGCCGTATGTGCCTGGCTGGGACTGTCaTGGtCTGCCAATCGAAcTGAAAGTAGAGCAAGAATACGGTAAGCCGGGgGAGaAaTTCACCGCCGcTGAGTtCCGCGCCAAGTGCCGCGAATACGCTGCgACCCAGGTTGACGGTCAGCGCAAAGACTTTaTCcGTCTGGGCGTGCTGGGCGActgGTCgcACCCGTACCTGACCATGGACtTCAAAACTGAAGCCAACATCATCCgCGCGCTGGGCAAAATCATCGGCAAcGGTCACCTGCACaAAGGcGCGAAGCCGGTgCACTGGTGCgTTGACTGCCGTTCTgCACTGGCAGAAGCGGAAGtTgAGTATTACGacAAAACTtCTCCGTCCATCGACGTCGCTTtCCAGGCGGTCGATCaGGATGCGCTGAAAACGAAATTTGGCGTAAGCAATgTTAACGGCCCAATTTCGCtGGTTATCTGGaCcACCACGcCGTGgAcGCTGCcTGCTAacCGCgCAATCTCcATtGCACCTGATTTTGAttATGCGCTGGTGCaAatCgACGGTCAGgCCGTGATCCTCGCGAAAGATCtGGtTGaAAGCGTAAtGCAGCGTATCGGCGTTAGCGaTTACACCATTCTTGGCAcGGtgAAAGGTGCCGAGCtGGAACTGTTgCGCTTTACCCATCCGTTtATGGACtTCGATGTTCCGGCAaTTCTCGGCGACcACGTTACgCTGGATGCCGGTACCGGTGcCGTTCATACCGCGCCAGGCcACGGTCCGGaCGACTATgTGATCGGTcAAAAATaTGgTCTGGAAaCCGCTAACCCgGTTgGCcCGGACGgCACtTaTCTGCcGgGTACTTACCCGACTCtGGATgGCGTTaACGTCTTCAAAGCGAACGaTATTGTCATTGCGTTGTTgCAGGAAAAAGGcgCACTGTTGCACGTTGAGAAAATGCAACACAGCTATCCGTgCTGCtGGCGTCaTAAaACGCCGATCAtCTTCCGcgCGACGCCGCAGTGGTTCGTCAgCAtgGATCAGAAAGGTCTGCgTGCGcAGTCACTGAAAGAGATCAAAGGCgTGCAGTGGATCCCTGACTGGGGCCAGGCGCGTATCGAGTCGATGGTTGCTAACCGTCCTGACTGGTGTATcTCTCGTCaGCGTACCTGGGGcGTGCCgATGTCACTGTTCGTgCaCAaaGACACAGAAGAaCTGcATCCGCgTACTCtcGAACTGaTGGAAGAAGTGGcAAAACGCGTTgAAGTtGACgGCATTCAGGCgTGGTGGGATCTCGATGCGAAaGAgATCcTCGGCGaCGAAGCTGACCAGTATGTGAAAGTACCGGATACGCtGgATGTATGGTtTGACTCCGGATCTACCCACTCTTCCGTTGTTGATGTGCGTcCGGAATtTGCCGGTCACGCAGCGGACATGTaTcTGgAaGGTTCTGACCAACACcGTGgCTGGTtCATGTCtTCCCTGATGATCTCTACCGCGATGAAGGGcAAAGcGCCATATCGTCAGGTACTGACTCACGGCTTTAcCGTGGATGGTCAGGGTCGCAAGATGTCTAAATCCATCGGtAACaCcGTTTCGCCGCAGGATGTgATGAATAAACtGGGtGCGGATATTCTGCGTCTGTGGGTGGcATCAACCGACTAcACTGGCGAAATGGCcGtTTCTGACGAGATCcTGAAACGtGCTGCcGACAGCTATCGTCGTATCcGTAACAcCgCGCGCTTCCTGCTGGCAAACCTGAACgGTTtTGAtCCGGCaAAAGaTATGGTGAAACCGGAAGAGATGGTGGTaCTGGATCGCTGGGCCGtAGGTTGTGCGAAAGCGGCACAGGAAGACATCCtCAAGGCgTACGAAGCATACGATTTCcACGAAGTGGTaCAGCGTcTGaTGCGCtTCTGCTCCGTTGAGATGgGTTccTTCTACCTCGACATCATCAAAGACCGTCAgTATACcGCCAAAGCGGaCAGCGTGGCGCGTCGTAGCTGCCAGAcTgCGCTGTATCACATCGCaGAAGCGCTGGTTCGCTGGATGGCAcCAATCCTCTCCTTCaCcGCTGaTGAAGTGTGGGGtTaCCTGCCggGCGAACGTGAAAAATACGTCTTCAcCGGCgAgTGgTACGAAGGCCTGtTTGGTCTGGCAGACAGTGAAGCAATGAACGaTGCGTTCTGGGACGAGCTGTTGAAAGTGcGTGGCGAAGTGAAcAAAGTcaTTGAGCAAGCgCGTGCCGATAAGAACGTGGGcGGCTCGCTGGAAGCGGCAGTAAcCTTGTATGCAGAACCGGAaCTGGCgGCGAaaCTGaCCGcGCTGGGCGAtGAATTACGATTTGTCCTGtTGACCTCCGgCGCTAcCGTTGcAGACtATAACGACGCACCTGCTGATGCCCAGCAGaGCGAaGTcCTCAAAGGGCTGAAAgtCGCGTTGAGTAAAGCCgAAGGtGaGAAGTGTCCtcGctGCTGgCACTACACCcAGgATGTcGgCAAGGTGGCGGaACACGCAGAAATCTGCGGCCGCTGTgTcAgCaACGTCGCCGGTGACGGTGAAAAaCGTAAGTTTGCCTGA
+Non-protein region
+GCTTGCGCCAACGcCATTTCATCGCCATCCCGCCgAgcATACAGGCCTCGgAaGAACCAaTGGTGTTGGTGcCAACGGCCtGAccATTTTTcGGTGCAGGCGCATGCCACAGATCGGCAACCATGTTTACGCAACGCAGATCGATTGCTGcAGaTTGCGGATATTctTCTTTGTCGATCCAGTTTTTGTtAATGGAtAAAtCCA
+FKBP-type 16 kDa peptidyl-prolyl cis-trans isomerase
+ATGTCTGAATCTGTACAGaGCAaTAgCGCCGTCCTGGTGCACTTCACGCTAAAACTCGACGAtGGCaCCAcCGCTGAGTCTACCCGCAaCAaCGGTAaACCGGCGCTGTTCCGCcTGgGTgATGCTTCTCTTTCTgAaGgGCTGGAGCAACACCTGCTgGGGCTGAAAGTGGgCGATAAAACCaCCTTCtCGCTGGAGCCAGATGCGGCgTTtgGCGTGCCGTcACCgGAcCTGATtCAGTAcTTCTCcCGCCGTGAATTTATGgATGCAGGCGAGCcaGAAATTGGCGCAATCATgCTTTTTACCGCAATGGaTGGCAGTGAGATGCCTGGCGTGaTCCGCgAAATTAACGGCGACTCCATTACCGTTGATTTCAACCaTCCGCTgGCCGGGCAGACCGTTCATTTTGATATTGaagTGCTGGaAATCGATCCGGCAcTGGAGGcGTaA

src/main/java/com/matthewjensen/project/modules/dna/output/dna.txt

@@ -0,0 +1,63 @@
+Region Name: cure for cancer protein
+Nucleotides: ATGCCACTATGGTAG
+Nuc. Counts: [4, 3, 4, 4]
+Total Mass%: [27.32, 16.84, 30.55, 25.29] of 1978.76
+Codons List: [ATG, CCA, CTA, TGG, TAG]
+Is Protein?: YES
+
+Region Name: captain picard hair growth protein
+Nucleotides: ATGCCAACATGGATGCCCGATATGGATTGA
+Nuc. Counts: [9, 6, 8, 7]
+Total Mass%: [30.65, 16.8, 30.47, 22.07] of 3967.54
+Codons List: [ATG, CCA, ACA, TGG, ATG, CCC, GAT, ATG, GAT, TGA]
+Is Protein?: YES
+
+Region Name: bogus protein
+Nucleotides: CCATTAATGATCACAGTT
+Nuc. Counts: [6, 4, 2, 6]
+Total Mass%: [35.13, 19.25, 13.1, 32.52] of 2308.08
+Codons List: [CCA, TTA, ATG, ATC, ACA, GTT]
+Is Protein?: NO
+
+Region Name: michael jordan mad hops protein
+Nucleotides: ATGAGATCCGTGATGTGGGATCCTACTCATTAA
+Nuc. Counts: [9, 6, 8, 10]
+Total Mass%: [28.0, 15.35, 27.84, 28.81] of 4342.86
+Codons List: [ATG, AGA, TCC, GTG, ATG, TGG, GAT, CCT, ACT, CAT, TAA]
+Is Protein?: YES
+
+Region Name: paris hilton phony protein
+Nucleotides: ATGCCAACATGGATGCCCTAAGATATGGATTAGTGA
+Nuc. Counts: [12, 6, 9, 9]
+Total Mass%: [33.96, 13.96, 28.49, 23.58] of 4774.27
+Codons List: [ATG, CCA, ACA, TGG, ATG, CCC, TAA, GAT, ATG, GAT, TAG, TGA]
+Is Protein?: YES
+
+Region Name: george w bush approval rating protein
+Nucleotides: ATGATAATTAGTTTTAATATCAGACTGTAA
+Nuc. Counts: [12, 2, 4, 12]
+Total Mass%: [41.06, 5.63, 15.31, 38.01] of 3949.54
+Codons List: [ATG, ATA, ATT, AGT, TTT, AAT, ATC, AGA, CTG, TAA]
+Is Protein?: NO
+
+Region Name: jimi hendrix guitar talent protein
+Nucleotides: ATGCAATTGCTCGATTAG
+Nuc. Counts: [5, 3, 4, 6]
+Total Mass%: [28.58, 14.1, 25.57, 31.75] of 2364.1
+Codons List: [ATG, CAA, TTG, CTC, GAT, TAG]
+Is Protein?: YES
+
+Region Name: tyler durden's brain protein
+Nucleotides: ATGATACCTATGAGTAATGTGGACCATATCCAAACTATAGGCATTGTCGGACCAACGATCGATTGGTTATACTGA
+Nuc. Counts: [24, 14, 16, 21]
+Total Mass%: [32.95, 15.8, 24.56, 26.69] of 9843.81
+Codons List: [ATG, ATA, CCT, ATG, AGT, AAT, GTG, GAC, CAT, ATC, CAA, ACT, ATA, GGC, ATT, GTC, GGA, CCA, ACG, ATC, GAT, TGG, TTA, TAC, TGA]
+Is Protein?: YES
+
+Region Name: mini me growth hormone
+Nucleotides: ATGGGACGCTGA
+Nuc. Counts: [3, 2, 5, 2]
+Total Mass%: [24.82, 13.6, 46.26, 15.32] of 1633.44
+Codons List: [ATG, GGA, CGC, TGA]
+Is Protein?: NO
+

src/main/java/com/matthewjensen/project/modules/dna/output/dna_file.txt

@@ -0,0 +1,63 @@
+Region Name: cure for cancer protein
+Nucleotides: ATGCCACTATGGTAG
+Nuc. Counts: [4, 3, 4, 4]
+Total Mass%: [27.51, 16.96, 30.77, 25.47] of 1964.7
+Codons List: [ATG, CCA, CTA, TGG, TAG]
+Is Protein?: YES
+
+Region Name: captain picard hair growth protein
+Nucleotides: ATGCCAACATGGATGCCCGATATGGATTGA
+Nuc. Counts: [9, 6, 8, 7]
+Total Mass%: [30.76, 16.86, 30.58, 22.15] of 3953.5
+Codons List: [ATG, CCA, ACA, TGG, ATG, CCC, GAT, ATG, GAT, TGA]
+Is Protein?: YES
+
+Region Name: bogus protein
+Nucleotides: CCATTAATGATCACAGTT
+Nuc. Counts: [6, 4, 2, 6]
+Total Mass%: [35.56, 19.49, 13.26, 32.92] of 2280.1
+Codons List: [CCA, TTA, ATG, ATC, ACA, GTT]
+Is Protein?: NO
+
+Region Name: michael jordan mad hops protein
+Nucleotides: ATGAGATCCGTGATGTGGGATCCTACTCATTAA
+Nuc. Counts: [9, 6, 8, 10]
+Total Mass%: [28.37, 15.55, 28.2, 29.18] of 4286.8
+Codons List: [ATG, AGA, TCC, GTG, ATG, TGG, GAT, CCT, ACT, CAT, TAA]
+Is Protein?: YES
+
+Region Name: paris hilton phony protein
+Nucleotides: ATGCCAACATGGATGCCCTAAGATATGGATTAGTGA
+Nuc. Counts: [12, 6, 9, 9]
+Total Mass%: [34.27, 14.09, 28.74, 23.79] of 4732.2
+Codons List: [ATG, CCA, ACA, TGG, ATG, CCC, TAA, GAT, ATG, GAT, TAG, TGA]
+Is Protein?: YES
+
+Region Name: george w bush approval rating protein
+Nucleotides: ATGATAATTAGTTTTAATATCAGACTGTAA
+Nuc. Counts: [12, 2, 4, 12]
+Total Mass%: [42.57, 5.83, 15.87, 39.41] of 3809.4
+Codons List: [ATG, ATA, ATT, AGT, TTT, AAT, ATC, AGA, CTG, TAA]
+Is Protein?: NO
+
+Region Name: jimi hendrix guitar talent protein
+Nucleotides: ATGCAATTGCTCGATTAG
+Nuc. Counts: [5, 3, 4, 6]
+Total Mass%: [29.1, 14.35, 26.03, 32.33] of 2322.0
+Codons List: [ATG, CAA, TTG, CTC, GAT, TAG]
+Is Protein?: YES
+
+Region Name: tyler durden's brain protein
+Nucleotides: ATGATACCTATGAGTAATGTGGACCATATCCAAACTATAGGCATTGTCGGACCAACGATCGATTGGTTATACTGA
+Nuc. Counts: [24, 14, 16, 21]
+Total Mass%: [33.28, 15.96, 24.81, 26.96] of 9745.8
+Codons List: [ATG, ATA, CCT, ATG, AGT, AAT, GTG, GAC, CAT, ATC, CAA, ACT, ATA, GGC, ATT, GTC, GGA, CCA, ACG, ATC, GAT, TGG, TTA, TAC, TGA]
+Is Protein?: YES
+
+Region Name: mini me growth hormone
+Nucleotides: ATGGGACGCTGA
+Nuc. Counts: [3, 2, 5, 2]
+Total Mass%: [24.82, 13.6, 46.26, 15.32] of 1633.4
+Codons List: [ATG, GGA, CGC, TGA]
+Is Protein?: NO
+

src/main/java/com/matthewjensen/project/modules/dna/output/ecoli.txt

@@ -0,0 +1,140 @@
+Region Name: thr operon leader peptide
+Nucleotides: ATGAAACGCATTAGCACCACCATTACCACCACCATCACCATTACCACAGGTAACGGTGCGGGCTGA
+Nuc. Counts: [21, 22, 12, 11]
+Total Mass%: [32.9, 28.34, 21.02, 15.95] of 8625.7
+Codons List: [ATG, AAA, CGC, ATT, AGC, ACC, ACC, ATT, ACC, ACC, ACC, ATC, ACC, ATT, ACC, ACA, GGT, AAC, GGT, GCG, GGC, TGA]
+Is Protein?: YES
+
+Region Name: aspartokinase I/homoserine dehydrogenase I
+Nucleotides: ATGCGAGTGTTGAAGTTCGGCGGTACATCAGTGGCAAATGCAGAACGTTTTCTGCGGGTTGCCGATATTCTGGAAAGCAATGCCAGGCAGGGGCAGGTGGCCACCGTCCTCTCTGCCCCCGCCAAAATCACCAACCATCTGGTAGCGATGATTGAAAAAACCATTAGCGGTCAGGATGCTTTACCCAATATCAGCGATGCCGAACGTATTTTTGCCGAACTTCTGACGGGACTCGCCGCCGCCCAGCCGGGATTTCCGCTGGCACAATTGAAAACTTTCGTCGACCAGGAATTTGCCCAAATAAAACATGTCCTGCATGGCATCAGTTTGTTGGGGCAGTGCCCGGATAGCATCAACGCTGCGCTGATTTGCCGTGGCGAGAAAATGTCGATCGCCATTATGGCCGGCGTGTTAGAAGCGCGTGGTCACAACGTTACCGTTATCGATCCGGTCGAAAAACTGCTGGCAGTGGGTCATTACCTCGAATCTACCGTTGATATTGCTGAATCCACCCGCCGTATTGCGGCAAGCCGCATTCCGGCTGACCACATGGTGCTGATGGCTGGTTTCACTGCCGGTAATGAAAAAGGCGAGCTGGTGGTTCTGGGACGCAACGGTTCCGACTACTCCGCTGCGGTGCTGGCGGCCTGTTTACGCGCCGATTGTTGCGAGATCTGGACGGATGTTGACGGTGTTTATACCTGCGATCCGCGTCAGGTGCCCGATGCGAGGTTGTTGAAGTCGATGTCCTATCAGGAAGCGATGGAGCTTTCTTACTTCGGCGCTAAAGTTCTTCACCCCCGCACCATTACCCCCATCGCCCAGTTCCAGATCCCTTGCCTGATTAAAAATACCGGAAATCCCCAAGCACCAGGTACGCTCATTGGTGCCAGCCGTGATGAAGACGAATTACCGGTCAAGGGCATTTCCAATCTGAATAACATGGCAATGTTCAGCGTTTCCGGCCCGGGGATGAAAGGGATGGTTGGCATGGCGGCGCGCGTCTTTGCAGCGATGTCACGCGCCCGTATTTCCGTGGTGCTGATTACGCAATCATCTTCCGAATACAGTATCAGTTTCTGCGTTCCGCAAAGCGACTGTGTGCGAGCTGAACGGGCAATGCAGGAAGAGTTCTACCTGGAACTGAAAGAAGGCTTACTGGAGCCGTTGGCGGTGACGGAACGGCTGGCCATTATCTCGGTGGTAGGTGATGGTATGCGCACCTTACGTGGGATCTCGGCGAAATTCTTTGCCGCGCTGGCCCGCGCCAATATCAACATTGTCGCCATTGCTCAGGGATCTTCTGAACGCTCAATCTCTGTCGTGGTCAATAACGATGATGCGACCACTGGCGTGCGCGTTACTCATCAGATGCTGTTCAATACCGATCAGGTTATCGAAGTGTTTGTGATTGGCGTCGGTGGCGTTGGCGGTGCGCTGCTGGAGCAACTGAAGCGTCAGCAAAGCTGGTTGAAGAATAAACATATCGACTTACGTGTCTGCGGTGTTGCTAACTCGAAGGCACTGCTCACCAATGTACATGGCCTTAATCTGGAAAACTGGCAGGAAGAACTGGCGCAAGCCAAAGAGCCGTTTAATCTCGGGCGCTTAATTCGCCTCGTGAAAGAATATCATCTGCTGAACCCGGTCATTGTTGACTGTACTTCCAGCCAGGCTGTGGCAGATCAATATGCCGACTTCCTGCGCGAAGGTTTCCACGTTGTTACGCCGAACAAAAAGGCCAACACCTCGTCGATGGATTACTACCATCAGTTGCGTTATGCGGCGGAAAAATCGCGGCGTAAATTCCTCTATGACACCAACGTTGGGGCTGGATTACCGGTTATTGAGAACCTGCAAAATCTGCTCAATGCTGGTGATGAATTGATGAAGTTCTCCGGCATTCTTTCAGGTTCGCTTTCTTATATCTTCGGCAAGTTAGACGAAGGCATGAGTTTCTCCGAGGCGACCACACTGGCGCGGGAAATGGGTTATACCGAACCGGACCCGCGAGATGATCTTTCTGGTATGGATGTGGCGCGTAAGCTATTGATTCTCGCTCGTGAAACGGGACGTGAACTGGAGCTGGCGGATATTGAAATTGAACCTGTGCTGCCCGCAGAGTTTAACGCCGAGGGTGATGTCGCCGCTTTTATGGCGAATCTGTCACAGCTCGACGATCTCTTTGCCGCGCGTGTGGCGAAGGCCCGTGATGAAGGAAAAGTTTTGCGCTATGTTGGCAATATTGATGAAGATGGCGTCTGCCGCGTGAAGATTGCCGAAGTGGATGGTAATGATCCGCTGTTCAAAGTGAAAAATGGCGAAAACGCCCTGGCCTTCTATAGCCACTATTATCAGCCGCTGCCGTTGGTACTGCGCGGATATGGTGCGGGCAATGACGTTACAGCTGCCGGTGTCTTTGCTGATCTGCTACGTACCCTCTCATGGAAGTTAGGAGTCTGA
+Nuc. Counts: [551, 608, 692, 612]
+Total Mass%: [23.04, 20.91, 32.37, 23.7] of 323096.2
+Codons List: [ATG, CGA, GTG, TTG, AAG, TTC, GGC, GGT, ACA, TCA, GTG, GCA, AAT, GCA, GAA, CGT, TTT, CTG, CGG, GTT, GCC, GAT, ATT, CTG, GAA, AGC, AAT, GCC, AGG, CAG, GGG, CAG, GTG, GCC, ACC, GTC, CTC, TCT, GCC, CCC, GCC, AAA, ATC, ACC, AAC, CAT, CTG, GTA, GCG, ATG, ATT, GAA, AAA, ACC, ATT, AGC, GGT, CAG, GAT, GCT, TTA, CCC, AAT, ATC, AGC, GAT, GCC, GAA, CGT, ATT, TTT, GCC, GAA, CTT, CTG, ACG, GGA, CTC, GCC, GCC, GCC, CAG, CCG, GGA, TTT, CCG, CTG, GCA, CAA, TTG, AAA, ACT, TTC, GTC, GAC, CAG, GAA, TTT, GCC, CAA, ATA, AAA, CAT, GTC, CTG, CAT, GGC, ATC, AGT, TTG, TTG, GGG, CAG, TGC, CCG, GAT, AGC, ATC, AAC, GCT, GCG, CTG, ATT, TGC, CGT, GGC, GAG, AAA, ATG, TCG, ATC, GCC, ATT, ATG, GCC, GGC, GTG, TTA, GAA, GCG, CGT, GGT, CAC, AAC, GTT, ACC, GTT, ATC, GAT, CCG, GTC, GAA, AAA, CTG, CTG, GCA, GTG, GGT, CAT, TAC, CTC, GAA, TCT, ACC, GTT, GAT, ATT, GCT, GAA, TCC, ACC, CGC, CGT, ATT, GCG, GCA, AGC, CGC, ATT, CCG, GCT, GAC, CAC, ATG, GTG, CTG, ATG, GCT, GGT, TTC, ACT, GCC, GGT, AAT, GAA, AAA, GGC, GAG, CTG, GTG, GTT, CTG, GGA, CGC, AAC, GGT, TCC, GAC, TAC, TCC, GCT, GCG, GTG, CTG, GCG, GCC, TGT, TTA, CGC, GCC, GAT, TGT, TGC, GAG, ATC, TGG, ACG, GAT, GTT, GAC, GGT, GTT, TAT, ACC, TGC, GAT, CCG, CGT, CAG, GTG, CCC, GAT, GCG, AGG, TTG, TTG, AAG, TCG, ATG, TCC, TAT, CAG, GAA, GCG, ATG, GAG, CTT, TCT, TAC, TTC, GGC, GCT, AAA, GTT, CTT, CAC, CCC, CGC, ACC, ATT, ACC, CCC, ATC, GCC, CAG, TTC, CAG, ATC, CCT, TGC, CTG, ATT, AAA, AAT, ACC, GGA, AAT, CCC, CAA, GCA, CCA, GGT, ACG, CTC, ATT, GGT, GCC, AGC, CGT, GAT, GAA, GAC, GAA, TTA, CCG, GTC, AAG, GGC, ATT, TCC, AAT, CTG, AAT, AAC, ATG, GCA, ATG, TTC, AGC, GTT, TCC, GGC, CCG, GGG, ATG, AAA, GGG, ATG, GTT, GGC, ATG, GCG, GCG, CGC, GTC, TTT, GCA, GCG, ATG, TCA, CGC, GCC, CGT, ATT, TCC, GTG, GTG, CTG, ATT, ACG, CAA, TCA, TCT, TCC, GAA, TAC, AGT, ATC, AGT, TTC, TGC, GTT, CCG, CAA, AGC, GAC, TGT, GTG, CGA, GCT, GAA, CGG, GCA, ATG, CAG, GAA, GAG, TTC, TAC, CTG, GAA, CTG, AAA, GAA, GGC, TTA, CTG, GAG, CCG, TTG, GCG, GTG, ACG, GAA, CGG, CTG, GCC, ATT, ATC, TCG, GTG, GTA, GGT, GAT, GGT, ATG, CGC, ACC, TTA, CGT, GGG, ATC, TCG, GCG, AAA, TTC, TTT, GCC, GCG, CTG, GCC, CGC, GCC, AAT, ATC, AAC, ATT, GTC, GCC, ATT, GCT, CAG, GGA, TCT, TCT, GAA, CGC, TCA, ATC, TCT, GTC, GTG, GTC, AAT, AAC, GAT, GAT, GCG, ACC, ACT, GGC, GTG, CGC, GTT, ACT, CAT, CAG, ATG, CTG, TTC, AAT, ACC, GAT, CAG, GTT, ATC, GAA, GTG, TTT, GTG, ATT, GGC, GTC, GGT, GGC, GTT, GGC, GGT, GCG, CTG, CTG, GAG, CAA, CTG, AAG, CGT, CAG, CAA, AGC, TGG, TTG, AAG, AAT, AAA, CAT, ATC, GAC, TTA, CGT, GTC, TGC, GGT, GTT, GCT, AAC, TCG, AAG, GCA, CTG, CTC, ACC, AAT, GTA, CAT, GGC, CTT, AAT, CTG, GAA, AAC, TGG, CAG, GAA, GAA, CTG, GCG, CAA, GCC, AAA, GAG, CCG, TTT, AAT, CTC, GGG, CGC, TTA, ATT, CGC, CTC, GTG, AAA, GAA, TAT, CAT, CTG, CTG, AAC, CCG, GTC, ATT, GTT, GAC, TGT, ACT, TCC, AGC, CAG, GCT, GTG, GCA, GAT, CAA, TAT, GCC, GAC, TTC, CTG, CGC, GAA, GGT, TTC, CAC, GTT, GTT, ACG, CCG, AAC, AAA, AAG, GCC, AAC, ACC, TCG, TCG, ATG, GAT, TAC, TAC, CAT, CAG, TTG, CGT, TAT, GCG, GCG, GAA, AAA, TCG, CGG, CGT, AAA, TTC, CTC, TAT, GAC, ACC, AAC, GTT, GGG, GCT, GGA, TTA, CCG, GTT, ATT, GAG, AAC, CTG, CAA, AAT, CTG, CTC, AAT, GCT, GGT, GAT, GAA, TTG, ATG, AAG, TTC, TCC, GGC, ATT, CTT, TCA, GGT, TCG, CTT, TCT, TAT, ATC, TTC, GGC, AAG, TTA, GAC, GAA, GGC, ATG, AGT, TTC, TCC, GAG, GCG, ACC, ACA, CTG, GCG, CGG, GAA, ATG, GGT, TAT, ACC, GAA, CCG, GAC, CCG, CGA, GAT, GAT, CTT, TCT, GGT, ATG, GAT, GTG, GCG, CGT, AAG, CTA, TTG, ATT, CTC, GCT, CGT, GAA, ACG, GGA, CGT, GAA, CTG, GAG, CTG, GCG, GAT, ATT, GAA, ATT, GAA, CCT, GTG, CTG, CCC, GCA, GAG, TTT, AAC, GCC, GAG, GGT, GAT, GTC, GCC, GCT, TTT, ATG, GCG, AAT, CTG, TCA, CAG, CTC, GAC, GAT, CTC, TTT, GCC, GCG, CGT, GTG, GCG, AAG, GCC, CGT, GAT, GAA, GGA, AAA, GTT, TTG, CGC, TAT, GTT, GGC, AAT, ATT, GAT, GAA, GAT, GGC, GTC, TGC, CGC, GTG, AAG, ATT, GCC, GAA, GTG, GAT, GGT, AAT, GAT, CCG, CTG, TTC, AAA, GTG, AAA, AAT, GGC, GAA, AAC, GCC, CTG, GCC, TTC, TAT, AGC, CAC, TAT, TAT, CAG, CCG, CTG, CCG, TTG, GTA, CTG, CGC, GGA, TAT, GGT, GCG, GGC, AAT, GAC, GTT, ACA, GCT, GCC, GGT, GTC, TTT, GCT, GAT, CTG, CTA, CGT, ACC, CTC, TCA, TGG, AAG, TTA, GGA, GTC, TGA]
+Is Protein?: YES
+
+Region Name: homoserine kinase
+Nucleotides: ATGGTTAAAGTTTATGCCCCGGCTTCCAGTGCCAATATGAGCGTCGGGTTTGATGTGCTCGGGGCGGCGGTGACACCTGTTGATGGTGCATTGCTCGGAGATGTAGTCACGGTTGAGGCGGCAGAGACATTCAGTCTCAACAACCTCGGACGCTTTGCCGATAAGCTGCCGTCAGAGCCACGGGAAAATATCGTTTATCAGTGCTGGGAGCGTTTTTGCCAGGAGCTTGGCAAGCAAATTCCAGTGGCGATGACTCTGGAAAAGAATATGCCGATCGGTTCGGGCTTAGGCTCCAGCGCCTGTTCAGTGGTCGCGGCGCTGATGGCGATGAATGAACACTGCGGCAAGCCGCTTAATGACACTCGTTTGCTGGCTTTGATGGGCGAGTTGGAAGGGCGTATCTCCGGCAGCATTCATTACGACAACGTGGCACCGTGTTTTCTTGGTGGTATGCAGTTGATGATCGAAGAAAACGACATCATCAGCCAGCAAGTGCCAGGGTTTGATGAGTGGCTGTGGGTGCTGGCGTATCCGGGGATTAAAGTCTCGACGGCAGAAGCCAGGGCTATTTTACCGGCGCAGTATCGCCGCCAGGATTGCATTGCGCACGGGCGACATCTGGCAGGCTTCATTCACGCCTGCTATTCCCGTCAGCTTGAGCTTGCCGCGAAGCTGATGAAAGATGTTATCGCTGAACCCTACCGTGAACGGTTACTGCCAGGCTTCCGGCAGGCGCGGCAGGCGGTTGCGGAAATCGGCGCGGTAGCGAGCGGTATCTCCGGCTCCGGCCCGACTTTGTTCGCTCTGTGTGACAAGCCGGATACCGCCCAGCGCGTTGCCGACTGGTTGGGTAAGAACTACCTGCAAAATCAGGAAGGTTTTGTTCATATTTGCCGGCTGGATACGGCGGGCGCACGAGTACTGGAAAACTAA
+Nuc. Counts: [193, 226, 295, 219]
+Total Mass%: [21.16, 20.37, 36.17, 22.23] of 123268.3
+Codons List: [ATG, GTT, AAA, GTT, TAT, GCC, CCG, GCT, TCC, AGT, GCC, AAT, ATG, AGC, GTC, GGG, TTT, GAT, GTG, CTC, GGG, GCG, GCG, GTG, ACA, CCT, GTT, GAT, GGT, GCA, TTG, CTC, GGA, GAT, GTA, GTC, ACG, GTT, GAG, GCG, GCA, GAG, ACA, TTC, AGT, CTC, AAC, AAC, CTC, GGA, CGC, TTT, GCC, GAT, AAG, CTG, CCG, TCA, GAG, CCA, CGG, GAA, AAT, ATC, GTT, TAT, CAG, TGC, TGG, GAG, CGT, TTT, TGC, CAG, GAG, CTT, GGC, AAG, CAA, ATT, CCA, GTG, GCG, ATG, ACT, CTG, GAA, AAG, AAT, ATG, CCG, ATC, GGT, TCG, GGC, TTA, GGC, TCC, AGC, GCC, TGT, TCA, GTG, GTC, GCG, GCG, CTG, ATG, GCG, ATG, AAT, GAA, CAC, TGC, GGC, AAG, CCG, CTT, AAT, GAC, ACT, CGT, TTG, CTG, GCT, TTG, ATG, GGC, GAG, TTG, GAA, GGG, CGT, ATC, TCC, GGC, AGC, ATT, CAT, TAC, GAC, AAC, GTG, GCA, CCG, TGT, TTT, CTT, GGT, GGT, ATG, CAG, TTG, ATG, ATC, GAA, GAA, AAC, GAC, ATC, ATC, AGC, CAG, CAA, GTG, CCA, GGG, TTT, GAT, GAG, TGG, CTG, TGG, GTG, CTG, GCG, TAT, CCG, GGG, ATT, AAA, GTC, TCG, ACG, GCA, GAA, GCC, AGG, GCT, ATT, TTA, CCG, GCG, CAG, TAT, CGC, CGC, CAG, GAT, TGC, ATT, GCG, CAC, GGG, CGA, CAT, CTG, GCA, GGC, TTC, ATT, CAC, GCC, TGC, TAT, TCC, CGT, CAG, CTT, GAG, CTT, GCC, GCG, AAG, CTG, ATG, AAA, GAT, GTT, ATC, GCT, GAA, CCC, TAC, CGT, GAA, CGG, TTA, CTG, CCA, GGC, TTC, CGG, CAG, GCG, CGG, CAG, GCG, GTT, GCG, GAA, ATC, GGC, GCG, GTA, GCG, AGC, GGT, ATC, TCC, GGC, TCC, GGC, CCG, ACT, TTG, TTC, GCT, CTG, TGT, GAC, AAG, CCG, GAT, ACC, GCC, CAG, CGC, GTT, GCC, GAC, TGG, TTG, GGT, AAG, AAC, TAC, CTG, CAA, AAT, CAG, GAA, GGT, TTT, GTT, CAT, ATT, TGC, CGG, CTG, GAT, ACG, GCG, GGC, GCA, CGA, GTA, CTG, GAA, AAC, TAA]
+Is Protein?: YES
+
+Region Name: threonine synthase
+Nucleotides: ATGAAACTCTACAATCTGAAAGATCACAATGAGCAGGTCAGCTTTGCGCAAGCCGTAACCCAGGGGTTAGGCAAAAATCAGGGGCTGTTTTTTCCGCACGACCTGCCGGAATTCAGCCTGACTGAAATTGATGAGATGCTGAAGCTGGATTTTGTCACCCGCAGTGCGAAGATCCTCTCGGCGTTTATTGGTGATGAAATCCCGCAGGAAATCCTGGAAGAGCGCGTACGTGCGGCGTTTGCCTTCCCGGCTCCGGTCGCCAATGTTGAAAGCGATGTCGGTTGTCTGGAATTGTTCCACGGGCCAACGCTGGCATTTAAAGATTTCGGCGGTCGCTTTATGGCACAAATGCTGACCCATATTGCGGGCGATAAGCCAGTGACCATTCTGACCGCGACATCCGGTGATACTGGAGCGGCAGTGGCTCATGCTTTCTACGGTTTACCGAATGTGAAAGTGGTTATCCTCTATCCACGAGGCAAAATCAGTCCACTGCAAGAAAAACTGTTCTGTACATTGGGCGGCAATATCGAAACTGTTGCCATCGACGGCGATTTCGATGCCTGTCAGGCGCTGGTGAAGCAGGCGTTTGATGATGAAGAACTGAAAGTGGCGCTGGGGCTGAATTCTGCTAACTCCATCAACATCAGTCGCTTGCTGGCGCAGATTTGTTATTACTTTGAGGCTGTCGCACAGTTGCCGCAAGAAGCACGTAACCAGTTGGTTGTCTCGGTACCGAGTGGAAACTTCGGCGATTTGACGGCGGGTCTGCTGGCGAAGTCACTCGGTCTGCCGGTAAAACGTTTTATTGCTGCGACCAACGTGAACGATACCGTACCACGTTTCCTGCACGACGGTCAGTGGTCACCCAAAGCGACTCAGGCGACGTTATCCAATGCGATGGATGTTAGCCAGCCAAACAACTGGCCGCGTGTGGAAGAGTTGTTCCGCCGCAAAATCTGGCAACTGAAAGAGCTGGGTTATGCAGCCGTGGATGATGAAACCACGCAACAGACAATGCGTGAGTTAAAAGAACTGGGCTATACCTCGGAGCCGCACGCTGCCGTAGCTTATCGTGCGCTGCGTGACCAGTTGAATCCAGGCGAATATGGCTTGTTCCTCGGCACCGCGCATCCGGCGAAATTTAAAGAGAGCGTGGAAGCGATTCTCGGTGAAACGTTGGATCTGCCAAAAGAGCTGGCAGAACGTGCTGATTTACCCTTGCTTTCGCATAACCTGCCCGCCGATTTTGCTGCGTTGCGTAAATTGATGATGAATCATCAGTAA
+Nuc. Counts: [309, 311, 358, 309]
+Total Mass%: [24.69, 20.43, 32.0, 22.86] of 169097.5
+Codons List: [ATG, AAA, CTC, TAC, AAT, CTG, AAA, GAT, CAC, AAT, GAG, CAG, GTC, AGC, TTT, GCG, CAA, GCC, GTA, ACC, CAG, GGG, TTA, GGC, AAA, AAT, CAG, GGG, CTG, TTT, TTT, CCG, CAC, GAC, CTG, CCG, GAA, TTC, AGC, CTG, ACT, GAA, ATT, GAT, GAG, ATG, CTG, AAG, CTG, GAT, TTT, GTC, ACC, CGC, AGT, GCG, AAG, ATC, CTC, TCG, GCG, TTT, ATT, GGT, GAT, GAA, ATC, CCG, CAG, GAA, ATC, CTG, GAA, GAG, CGC, GTA, CGT, GCG, GCG, TTT, GCC, TTC, CCG, GCT, CCG, GTC, GCC, AAT, GTT, GAA, AGC, GAT, GTC, GGT, TGT, CTG, GAA, TTG, TTC, CAC, GGG, CCA, ACG, CTG, GCA, TTT, AAA, GAT, TTC, GGC, GGT, CGC, TTT, ATG, GCA, CAA, ATG, CTG, ACC, CAT, ATT, GCG, GGC, GAT, AAG, CCA, GTG, ACC, ATT, CTG, ACC, GCG, ACA, TCC, GGT, GAT, ACT, GGA, GCG, GCA, GTG, GCT, CAT, GCT, TTC, TAC, GGT, TTA, CCG, AAT, GTG, AAA, GTG, GTT, ATC, CTC, TAT, CCA, CGA, GGC, AAA, ATC, AGT, CCA, CTG, CAA, GAA, AAA, CTG, TTC, TGT, ACA, TTG, GGC, GGC, AAT, ATC, GAA, ACT, GTT, GCC, ATC, GAC, GGC, GAT, TTC, GAT, GCC, TGT, CAG, GCG, CTG, GTG, AAG, CAG, GCG, TTT, GAT, GAT, GAA, GAA, CTG, AAA, GTG, GCG, CTG, GGG, CTG, AAT, TCT, GCT, AAC, TCC, ATC, AAC, ATC, AGT, CGC, TTG, CTG, GCG, CAG, ATT, TGT, TAT, TAC, TTT, GAG, GCT, GTC, GCA, CAG, TTG, CCG, CAA, GAA, GCA, CGT, AAC, CAG, TTG, GTT, GTC, TCG, GTA, CCG, AGT, GGA, AAC, TTC, GGC, GAT, TTG, ACG, GCG, GGT, CTG, CTG, GCG, AAG, TCA, CTC, GGT, CTG, CCG, GTA, AAA, CGT, TTT, ATT, GCT, GCG, ACC, AAC, GTG, AAC, GAT, ACC, GTA, CCA, CGT, TTC, CTG, CAC, GAC, GGT, CAG, TGG, TCA, CCC, AAA, GCG, ACT, CAG, GCG, ACG, TTA, TCC, AAT, GCG, ATG, GAT, GTT, AGC, CAG, CCA, AAC, AAC, TGG, CCG, CGT, GTG, GAA, GAG, TTG, TTC, CGC, CGC, AAA, ATC, TGG, CAA, CTG, AAA, GAG, CTG, GGT, TAT, GCA, GCC, GTG, GAT, GAT, GAA, ACC, ACG, CAA, CAG, ACA, ATG, CGT, GAG, TTA, AAA, GAA, CTG, GGC, TAT, ACC, TCG, GAG, CCG, CAC, GCT, GCC, GTA, GCT, TAT, CGT, GCG, CTG, CGT, GAC, CAG, TTG, AAT, CCA, GGC, GAA, TAT, GGC, TTG, TTC, CTC, GGC, ACC, GCG, CAT, CCG, GCG, AAA, TTT, AAA, GAG, AGC, GTG, GAA, GCG, ATT, CTC, GGT, GAA, ACG, TTG, GAT, CTG, CCA, AAA, GAG, CTG, GCA, GAA, CGT, GCT, GAT, TTA, CCC, TTG, CTT, TCG, CAT, AAC, CTG, CCC, GCC, GAT, TTT, GCT, GCG, TTG, CGT, AAA, TTG, ATG, ATG, AAT, CAT, CAG, TAA]
+Is Protein?: YES
+
+Region Name: hypothetical protein
+Nucleotides: ATGCAGCCCGGCTTTTTTTATGAAGAAAATATGGAGAAAAACGACAGGGAAAAAGGAGAAATTCTCAATAAATGCGGTAACTTAGAGATTAGGATTGCGGAGAATAACAACTGCCGTTCTCATCGCGTAATCTCCGGATATCGACCCATAACGGGCAATGATAAAAGGAGTAACCTGTGA
+Nuc. Counts: [66, 31, 43, 40]
+Total Mass%: [37.57, 14.51, 27.37, 21.08] of 23739.3
+Codons List: [ATG, CAG, CCC, GGC, TTT, TTT, TAT, GAA, GAA, AAT, ATG, GAG, AAA, AAC, GAC, AGG, GAA, AAA, GGA, GAA, ATT, CTC, AAT, AAA, TGC, GGT, AAC, TTA, GAG, ATT, AGG, ATT, GCG, GAG, AAT, AAC, AAC, TGC, CGT, TCT, CAT, CGC, GTA, ATC, TCC, GGA, TAT, CGA, CCC, ATA, ACG, GGC, AAT, GAT, AAA, AGG, AGT, AAC, CTG, TGA]
+Is Protein?: YES
+
+Region Name: Non-protein region
+Nucleotides: AAAAACTGCTGGAAACAATGAAAGACGTACCGGACGACCAACGTCAGGCGC
+Nuc. Counts: [20, 13, 13, 5]
+Total Mass%: [39.46, 21.09, 28.68, 9.13] of 6849.2
+Codons List: [AAA, AAC, TGC, TGG, AAA, CAA, TGA, AAG, ACG, TAC, CGG, ACG, ACC, AAC, GTC, AGG, CGC]
+Is Protein?: NO
+
+Region Name: transaldolase B
+Nucleotides: ATGACGGACAAATTGACCTCCCTTCGTCAGTACACCACCGTAGTGGCCGACACTGGGGACATCGCGGCAATGAAGCTGTATCAACCGCAGGATGCCACAACCAACCCTTCTCTCATTCTTAACGCAGCGCAGATTCCGGAATACCGTAAGTTGATTGATGATGCTGTCGCCTGGGCGAAACAGCAGAGCAACGATCGCGCGCAGCAGATCGTGGACGCGACCGACAAACTGGCAGTAAATATTGGTCTGGAAATCCTGAAACTGGTTCCGGGCCGTATCTCAACTGAAGTTGATGCGCGTCTTTCCTATGACACCGAAGCGTCAATTGCGAAAGCAAAACGCCTGATCAAACTCTACAACGATGCAGGTATTAGCAACGATCGTATTCTGATCAAACTGGCTTCTACCTGGCAGGGTATCCGTGCTGCAGAACAGCTGGAAAAAGAAGGTATTAACTGTAACCTGACCCTGCTGTTCTCCTTCGCTCAGGCTCGTGCTTGTGCGGAAGCGGGCGTGTTCCTGATCTCGCCGTTTGTTGGCCGTATTCTTGACTGGTACAAAGCGAATACCGATAAGAAAGAGTACGCTCCGGCAGAAGATCCGGGCGTGGTTTCTGTATCTGAAATCTACCAGTACTACAAAGAGCATGGTTATGAAACCGTGGTTATGGGCGCAAGCTTCCGTAACATCGGCGAAATTCTGGAACTGGCAGGCTGCGACCGTCTGACCATCGCACCGGCACTGCTGAAAGAGCTGGCGGAGAGCGAAGGGGCTATCGAACGTAAACTGTCTTACACTGGTGAAGTGAAAGCGCGTCCGGCGCGTATCACTGAGTCCGAGTTCCTGTGGCAGCACAACCAGGATCCAATGGCAGTAGATAAACTGGCGGAAGGTATCCGTAAGTTTGCTGTTGACCAGGAAAAACTGGAAAAAATGATCGGCGATCTGCTGTAA
+Nuc. Counts: [252, 236, 256, 210]
+Total Mass%: [27.11, 20.88, 30.8, 20.92] of 125598.0
+Codons List: [ATG, ACG, GAC, AAA, TTG, ACC, TCC, CTT, CGT, CAG, TAC, ACC, ACC, GTA, GTG, GCC, GAC, ACT, GGG, GAC, ATC, GCG, GCA, ATG, AAG, CTG, TAT, CAA, CCG, CAG, GAT, GCC, ACA, ACC, AAC, CCT, TCT, CTC, ATT, CTT, AAC, GCA, GCG, CAG, ATT, CCG, GAA, TAC, CGT, AAG, TTG, ATT, GAT, GAT, GCT, GTC, GCC, TGG, GCG, AAA, CAG, CAG, AGC, AAC, GAT, CGC, GCG, CAG, CAG, ATC, GTG, GAC, GCG, ACC, GAC, AAA, CTG, GCA, GTA, AAT, ATT, GGT, CTG, GAA, ATC, CTG, AAA, CTG, GTT, CCG, GGC, CGT, ATC, TCA, ACT, GAA, GTT, GAT, GCG, CGT, CTT, TCC, TAT, GAC, ACC, GAA, GCG, TCA, ATT, GCG, AAA, GCA, AAA, CGC, CTG, ATC, AAA, CTC, TAC, AAC, GAT, GCA, GGT, ATT, AGC, AAC, GAT, CGT, ATT, CTG, ATC, AAA, CTG, GCT, TCT, ACC, TGG, CAG, GGT, ATC, CGT, GCT, GCA, GAA, CAG, CTG, GAA, AAA, GAA, GGT, ATT, AAC, TGT, AAC, CTG, ACC, CTG, CTG, TTC, TCC, TTC, GCT, CAG, GCT, CGT, GCT, TGT, GCG, GAA, GCG, GGC, GTG, TTC, CTG, ATC, TCG, CCG, TTT, GTT, GGC, CGT, ATT, CTT, GAC, TGG, TAC, AAA, GCG, AAT, ACC, GAT, AAG, AAA, GAG, TAC, GCT, CCG, GCA, GAA, GAT, CCG, GGC, GTG, GTT, TCT, GTA, TCT, GAA, ATC, TAC, CAG, TAC, TAC, AAA, GAG, CAT, GGT, TAT, GAA, ACC, GTG, GTT, ATG, GGC, GCA, AGC, TTC, CGT, AAC, ATC, GGC, GAA, ATT, CTG, GAA, CTG, GCA, GGC, TGC, GAC, CGT, CTG, ACC, ATC, GCA, CCG, GCA, CTG, CTG, AAA, GAG, CTG, GCG, GAG, AGC, GAA, GGG, GCT, ATC, GAA, CGT, AAA, CTG, TCT, TAC, ACT, GGT, GAA, GTG, AAA, GCG, CGT, CCG, GCG, CGT, ATC, ACT, GAG, TCC, GAG, TTC, CTG, TGG, CAG, CAC, AAC, CAG, GAT, CCA, ATG, GCA, GTA, GAT, AAA, CTG, GCG, GAA, GGT, ATC, CGT, AAG, TTT, GCT, GTT, GAC, CAG, GAA, AAA, CTG, GAA, AAA, ATG, ATC, GGC, GAT, CTG, CTG, TAA]
+Is Protein?: YES
+
+Region Name: molybdopterin biosynthesis mog protein
+Nucleotides: ATGAATACTTTACGTATTGGCTTAGTTTCCATCTCTGATCGCGCATCCAGCGGCGTTTATCAGGATAAAGGCATCCCTGCGCTGGAAGAATGGCTGACATCGGCGCTAACCACGCCGTTTGAACTGGAAACCCGCTTAATCCCCGATGAGCAGGCGATCATCGAGCAAACGTTGTGTGAGCTGGTGGATGAAATGAGTTGCCATCTGGTGCTCACCACGGGCGGAACTGGCCCTGCGCGTCGTGACGTAACGCCCGATGCGACGCTGGCAGTAGCGGACCGCGAGATGCCAGGCTTTGGTGAACAGATGCGCCAGATCAGCCTGCATTTTGTACCAACTGCGATCCTTTCGCGTCAGGTGGGGGTGATTCGCAAACAGGCGCTGATCCTTAACTTACCCGGTCAACCGAAGTCTATTAAAGAGACGCTGGAAGGTGTGAAGGACGCTGAGGGTAACGTTGTGGTGCACGGTATTTTTGCCAGCGTACCGTACTGCATTCAGTTGCTGGAAGGGCCATACGTTGAAACGGCACCGGAAGTGGTTGCAGCATTCAGACCGAAGAGTGCAAGACGCGAAGTTAGCGAATAA
+Nuc. Counts: [139, 143, 175, 131]
+Total Mass%: [24.18, 20.45, 34.05, 21.1] of 77675.0
+Codons List: [ATG, AAT, ACT, TTA, CGT, ATT, GGC, TTA, GTT, TCC, ATC, TCT, GAT, CGC, GCA, TCC, AGC, GGC, GTT, TAT, CAG, GAT, AAA, GGC, ATC, CCT, GCG, CTG, GAA, GAA, TGG, CTG, ACA, TCG, GCG, CTA, ACC, ACG, CCG, TTT, GAA, CTG, GAA, ACC, CGC, TTA, ATC, CCC, GAT, GAG, CAG, GCG, ATC, ATC, GAG, CAA, ACG, TTG, TGT, GAG, CTG, GTG, GAT, GAA, ATG, AGT, TGC, CAT, CTG, GTG, CTC, ACC, ACG, GGC, GGA, ACT, GGC, CCT, GCG, CGT, CGT, GAC, GTA, ACG, CCC, GAT, GCG, ACG, CTG, GCA, GTA, GCG, GAC, CGC, GAG, ATG, CCA, GGC, TTT, GGT, GAA, CAG, ATG, CGC, CAG, ATC, AGC, CTG, CAT, TTT, GTA, CCA, ACT, GCG, ATC, CTT, TCG, CGT, CAG, GTG, GGG, GTG, ATT, CGC, AAA, CAG, GCG, CTG, ATC, CTT, AAC, TTA, CCC, GGT, CAA, CCG, AAG, TCT, ATT, AAA, GAG, ACG, CTG, GAA, GGT, GTG, AAG, GAC, GCT, GAG, GGT, AAC, GTT, GTG, GTG, CAC, GGT, ATT, TTT, GCC, AGC, GTA, CCG, TAC, TGC, ATT, CAG, TTG, CTG, GAA, GGG, CCA, TAC, GTT, GAA, ACG, GCA, CCG, GAA, GTG, GTT, GCA, GCA, TTC, AGA, CCG, AAG, AGT, GCA, AGA, CGC, GAA, GTT, AGC, GAA, TAA]
+Is Protein?: YES
+
+Region Name: chaperone protein DnaK
+Nucleotides: ATGGGTAAAATAATTGGTATCGACCTGGGTACTACCAACTCTTGTGTAGCGATTATGGATGGCACCACTCCTCGTGTACTGGAGAACGCCGAAGGCGATCGCACCACGCCTTCTATCATTGCCTATACCCAGGATGGTGAAACTCTGGTTGGTCAGCCGGCTAAACGTCAGGCAGTGACGAACCCGCAAAACACCCTGTTTGCGATTAAACGCCTGATTGGCCGCCGCTTCCAGGACGAAGAAGTACAGCGTGATGTTTCCATCATGCCGTTCAAAATTATTGCTGCTGATAACGGCGACGCATGGGTCGAAGTTAAAGGCCAGAAAATGGCACCGCCGCAGATCTCTGCTGAAGTGCTGAAAAAAATGAAGAAAACCGCTGAAGATTACCTGGGTGAACCGGTAACTGAAGCTGTTATTACCGTACCGGCATACTTTAACGATGCTCAGCGTCAGGCAACCAAAGACGCAGGCCGTATCGCTGGTCTGGAAGTAAAACGTATCATCAACGAACCGACCGCAGCTGCGCTGGCTTACGGTCTGGACAAAGGTACTGGCAACCGTACTATCGCGGTTTATGACCTGGGTGGTGGTACTTTCGATATTTCCATTATCGAAATCGACGAAGTTGACGGCGAAAAAACCTTCGAAGTTCTGGCAACCAACGGTGATACCCACCTGGGTGGTGAAGACTTCGACAGTCGTCTGATCAACTATCTGGTTGAAGAATTCAAGAAAGATCAGGGCATTGACCTGCGCAACGATCCGCTGGCAATGCAGCGCCTGAAAGAAGCGGCAGAAAAAGCGAAAATCGAACTGTCTTCCGCTCAGCAGACCGACGTTAACCTGCCGTACATCACTGCAGACGCGACCGGTCCGAAACACATGAACATCAAAGTGACTCGTGCGAAACTGGAAAGCCTGGTTGAAGATCTGGTAAACCGTTCCATTGAGCCGCTGAAAGTTGCACTGCAGGACGCTGGCCTGTCCGTATCTGATATCGACGACGTTATTCTCGTTGGTGGTCAGACTCGTATGCCAATGGTTCAGAAGAAAGTTGCTGAATTCTTTGGTAAAGAGCCGCGTAAAGATGTTAACCCGGACGAAGCTGTAGCCATCGGTGCTGCTGTTCAGGGTGGTGTTCTGACTGGTGACGTAAAAGACGTACTGCTGCTGGACGTTACCCCGCTGTCTCTGGGTATCGAAACCATGGGCGGTGTGATGACCACGCTGATCGCGAAAAACACCACTATCCCGACCAAGCACAGCCAGGTGTTCTCTACCGCTGAAGACAACCAGTCTGCGGTAACCATCCATGTGCTGCAGGGTGAACGTAAACGTGCGGCTGATAACAAATCTCTGGGTCAGTTCAACCTGGATGGTATCAACCCGGCACCGCGCGGCATGCCGCAGATCGAAGTTACCTTCGATATCGATGCTGACGGTATCCTGCACGTTTCCGCGAAAGACAAAAACAGCGGTAAAGAGCAGAAGATCACTATCAAGGCTTCTTCTGGTCTGAACGAAGATGAAATCCAGAAAATGGTACGCGACGCAGAAGCTAACGCCGAAGCTGACCGTAAGTTTGAAGAGCTGGTACAGACTCGCAACCAGGGCGACCATCTGCTGCACAGCACCCGTAAGCAGGTTGAAGAAGCAGGCGACAAACTGCCGGCTGACGACAAAACTGCTATCGAGTCTGCGCTGACTGCACTGGAAACTGCTCTGAAAGGTGAAGACAAAGCCGCTATCGAAGCGAAAATGCAGGAACTGGCACAGGTTTCCCAGAAACTGATGGAAATCGCCCAGCAGCAACATGCCCAGCAGCAGACTGCCGGTGCTGATGCTTCTGCAAACAACGCGAAAGATGACGATGTTGTCGACGCTGAATTTGAAGAAGTCAAAGACAAAAAATAA
+Nuc. Counts: [541, 475, 504, 397]
+Total Mass%: [28.92, 20.88, 30.13, 19.65] of 252806.4
+Codons List: [ATG, GGT, AAA, ATA, ATT, GGT, ATC, GAC, CTG, GGT, ACT, ACC, AAC, TCT, TGT, GTA, GCG, ATT, ATG, GAT, GGC, ACC, ACT, CCT, CGT, GTA, CTG, GAG, AAC, GCC, GAA, GGC, GAT, CGC, ACC, ACG, CCT, TCT, ATC, ATT, GCC, TAT, ACC, CAG, GAT, GGT, GAA, ACT, CTG, GTT, GGT, CAG, CCG, GCT, AAA, CGT, CAG, GCA, GTG, ACG, AAC, CCG, CAA, AAC, ACC, CTG, TTT, GCG, ATT, AAA, CGC, CTG, ATT, GGC, CGC, CGC, TTC, CAG, GAC, GAA, GAA, GTA, CAG, CGT, GAT, GTT, TCC, ATC, ATG, CCG, TTC, AAA, ATT, ATT, GCT, GCT, GAT, AAC, GGC, GAC, GCA, TGG, GTC, GAA, GTT, AAA, GGC, CAG, AAA, ATG, GCA, CCG, CCG, CAG, ATC, TCT, GCT, GAA, GTG, CTG, AAA, AAA, ATG, AAG, AAA, ACC, GCT, GAA, GAT, TAC, CTG, GGT, GAA, CCG, GTA, ACT, GAA, GCT, GTT, ATT, ACC, GTA, CCG, GCA, TAC, TTT, AAC, GAT, GCT, CAG, CGT, CAG, GCA, ACC, AAA, GAC, GCA, GGC, CGT, ATC, GCT, GGT, CTG, GAA, GTA, AAA, CGT, ATC, ATC, AAC, GAA, CCG, ACC, GCA, GCT, GCG, CTG, GCT, TAC, GGT, CTG, GAC, AAA, GGT, ACT, GGC, AAC, CGT, ACT, ATC, GCG, GTT, TAT, GAC, CTG, GGT, GGT, GGT, ACT, TTC, GAT, ATT, TCC, ATT, ATC, GAA, ATC, GAC, GAA, GTT, GAC, GGC, GAA, AAA, ACC, TTC, GAA, GTT, CTG, GCA, ACC, AAC, GGT, GAT, ACC, CAC, CTG, GGT, GGT, GAA, GAC, TTC, GAC, AGT, CGT, CTG, ATC, AAC, TAT, CTG, GTT, GAA, GAA, TTC, AAG, AAA, GAT, CAG, GGC, ATT, GAC, CTG, CGC, AAC, GAT, CCG, CTG, GCA, ATG, CAG, CGC, CTG, AAA, GAA, GCG, GCA, GAA, AAA, GCG, AAA, ATC, GAA, CTG, TCT, TCC, GCT, CAG, CAG, ACC, GAC, GTT, AAC, CTG, CCG, TAC, ATC, ACT, GCA, GAC, GCG, ACC, GGT, CCG, AAA, CAC, ATG, AAC, ATC, AAA, GTG, ACT, CGT, GCG, AAA, CTG, GAA, AGC, CTG, GTT, GAA, GAT, CTG, GTA, AAC, CGT, TCC, ATT, GAG, CCG, CTG, AAA, GTT, GCA, CTG, CAG, GAC, GCT, GGC, CTG, TCC, GTA, TCT, GAT, ATC, GAC, GAC, GTT, ATT, CTC, GTT, GGT, GGT, CAG, ACT, CGT, ATG, CCA, ATG, GTT, CAG, AAG, AAA, GTT, GCT, GAA, TTC, TTT, GGT, AAA, GAG, CCG, CGT, AAA, GAT, GTT, AAC, CCG, GAC, GAA, GCT, GTA, GCC, ATC, GGT, GCT, GCT, GTT, CAG, GGT, GGT, GTT, CTG, ACT, GGT, GAC, GTA, AAA, GAC, GTA, CTG, CTG, CTG, GAC, GTT, ACC, CCG, CTG, TCT, CTG, GGT, ATC, GAA, ACC, ATG, GGC, GGT, GTG, ATG, ACC, ACG, CTG, ATC, GCG, AAA, AAC, ACC, ACT, ATC, CCG, ACC, AAG, CAC, AGC, CAG, GTG, TTC, TCT, ACC, GCT, GAA, GAC, AAC, CAG, TCT, GCG, GTA, ACC, ATC, CAT, GTG, CTG, CAG, GGT, GAA, CGT, AAA, CGT, GCG, GCT, GAT, AAC, AAA, TCT, CTG, GGT, CAG, TTC, AAC, CTG, GAT, GGT, ATC, AAC, CCG, GCA, CCG, CGC, GGC, ATG, CCG, CAG, ATC, GAA, GTT, ACC, TTC, GAT, ATC, GAT, GCT, GAC, GGT, ATC, CTG, CAC, GTT, TCC, GCG, AAA, GAC, AAA, AAC, AGC, GGT, AAA, GAG, CAG, AAG, ATC, ACT, ATC, AAG, GCT, TCT, TCT, GGT, CTG, AAC, GAA, GAT, GAA, ATC, CAG, AAA, ATG, GTA, CGC, GAC, GCA, GAA, GCT, AAC, GCC, GAA, GCT, GAC, CGT, AAG, TTT, GAA, GAG, CTG, GTA, CAG, ACT, CGC, AAC, CAG, GGC, GAC, CAT, CTG, CTG, CAC, AGC, ACC, CGT, AAG, CAG, GTT, GAA, GAA, GCA, GGC, GAC, AAA, CTG, CCG, GCT, GAC, GAC, AAA, ACT, GCT, ATC, GAG, TCT, GCG, CTG, ACT, GCA, CTG, GAA, ACT, GCT, CTG, AAA, GGT, GAA, GAC, AAA, GCC, GCT, ATC, GAA, GCG, AAA, ATG, CAG, GAA, CTG, GCA, CAG, GTT, TCC, CAG, AAA, CTG, ATG, GAA, ATC, GCC, CAG, CAG, CAA, CAT, GCC, CAG, CAG, CAG, ACT, GCC, GGT, GCT, GAT, GCT, TCT, GCA, AAC, AAC, GCG, AAA, GAT, GAC, GAT, GTT, GTC, GAC, GCT, GAA, TTT, GAA, GAA, GTC, AAA, GAC, AAA, AAA, TAA]
+Is Protein?: YES
+
+Region Name: chaperone protein DnaJ
+Nucleotides: GTGCATTCATCTAGGGGCAATTTAAAAAAGATGGCTAAGCAAGATTATTACGAGATTTTAGGCGTTTCCAAAACAGCGGAAGAGCGTGAAATCAAAAAGGCCTACAAACGCCTGGCCATGAAATACCACCCGGACCGTAACCAGGGTGACAAAGAGGCCGAGGCGAAATTTAAAGAGATCAAGGAAGCTTATGAAGTTCTGACCGACTCGCAAAAACGTGCGGCATACGATCAGTATGGTCATGCTGCGTTTGAGCAAGGTGGCATGGGCGGCGGCGGTTTTGGCGGCGGCGCAGACTTCAGCGATATTTTTGGTGACGTTTTCGGCGATATTTTTGGCGGCGGACGTGGTCGTCAACGTGCGGCGCGCGGTGCTGATTTACGCTATAACATGGAGCTCACCCTCGAAGAAGCTGTACGTGGCGTGACCAAAGAGATCCGCATTCCGACTCTGGAAGAGTGTGACGTTTGCCACGGTAGCGGTGCAAAACCAGGTACACAGCCGCAGACCTGTCCGACCTGTCATGGTTCTGGCCAGGTGCAGATGCGCCAGGGTTTCTTTGCCGTGCAGCAGACCTGTCCACACTGTCAGGGCCGCGGTACGCTGATCAAAGATCCGTGCAACAAATGTCATGGTCATGGTCGTGTTGAGCGCAGCAAAACGCTGTCCGTTAAAATCCCGGCAGGGGTGGACACTGGAGACCGCATCCGTCTTGCGGGCGAAGGTGAAGCGGGTGAACACGGCGCACCGGCAGGCGATCTGTACGTTCAGGTTCAGGTTAAACAGCACCCGATTTTCGAGCGTGAAGGCAACAACCTGTATTGCGAAGTCCCGATCAACTTCGCTATGGCGGCGCTGGGTGGTGAAATCGAAGTACCGACCCTTGATGGTCGCGTCAAACTGAAAGTGCCTGGCGAAACCCAGACCGGTAAGCTGTTCCGTATGCGCGGTAAAGGCGTCAAGTCTGTCCGCGGTGGCGCACAGGGTGATTTGCTATGCCGCGTTGTTGTCGAAACACCGGTAGGTTTGAACGAGAAGCAGAAACAGCTGCTGCAAGAGCTGCAAGAAAGCTTTGGTGGCCCAACCGGCGAGCACAACAGCCCGCGTTCAAAGAGCTTCTTTGATGGCGTGAAGAAGTTTTTTGACGACCTGACTCGCTAA
+Nuc. Counts: [287, 278, 352, 244]
+Total Mass%: [25.2, 20.07, 34.57, 19.84] of 153867.6
+Codons List: [GTG, CAT, TCA, TCT, AGG, GGC, AAT, TTA, AAA, AAG, ATG, GCT, AAG, CAA, GAT, TAT, TAC, GAG, ATT, TTA, GGC, GTT, TCC, AAA, ACA, GCG, GAA, GAG, CGT, GAA, ATC, AAA, AAG, GCC, TAC, AAA, CGC, CTG, GCC, ATG, AAA, TAC, CAC, CCG, GAC, CGT, AAC, CAG, GGT, GAC, AAA, GAG, GCC, GAG, GCG, AAA, TTT, AAA, GAG, ATC, AAG, GAA, GCT, TAT, GAA, GTT, CTG, ACC, GAC, TCG, CAA, AAA, CGT, GCG, GCA, TAC, GAT, CAG, TAT, GGT, CAT, GCT, GCG, TTT, GAG, CAA, GGT, GGC, ATG, GGC, GGC, GGC, GGT, TTT, GGC, GGC, GGC, GCA, GAC, TTC, AGC, GAT, ATT, TTT, GGT, GAC, GTT, TTC, GGC, GAT, ATT, TTT, GGC, GGC, GGA, CGT, GGT, CGT, CAA, CGT, GCG, GCG, CGC, GGT, GCT, GAT, TTA, CGC, TAT, AAC, ATG, GAG, CTC, ACC, CTC, GAA, GAA, GCT, GTA, CGT, GGC, GTG, ACC, AAA, GAG, ATC, CGC, ATT, CCG, ACT, CTG, GAA, GAG, TGT, GAC, GTT, TGC, CAC, GGT, AGC, GGT, GCA, AAA, CCA, GGT, ACA, CAG, CCG, CAG, ACC, TGT, CCG, ACC, TGT, CAT, GGT, TCT, GGC, CAG, GTG, CAG, ATG, CGC, CAG, GGT, TTC, TTT, GCC, GTG, CAG, CAG, ACC, TGT, CCA, CAC, TGT, CAG, GGC, CGC, GGT, ACG, CTG, ATC, AAA, GAT, CCG, TGC, AAC, AAA, TGT, CAT, GGT, CAT, GGT, CGT, GTT, GAG, CGC, AGC, AAA, ACG, CTG, TCC, GTT, AAA, ATC, CCG, GCA, GGG, GTG, GAC, ACT, GGA, GAC, CGC, ATC, CGT, CTT, GCG, GGC, GAA, GGT, GAA, GCG, GGT, GAA, CAC, GGC, GCA, CCG, GCA, GGC, GAT, CTG, TAC, GTT, CAG, GTT, CAG, GTT, AAA, CAG, CAC, CCG, ATT, TTC, GAG, CGT, GAA, GGC, AAC, AAC, CTG, TAT, TGC, GAA, GTC, CCG, ATC, AAC, TTC, GCT, ATG, GCG, GCG, CTG, GGT, GGT, GAA, ATC, GAA, GTA, CCG, ACC, CTT, GAT, GGT, CGC, GTC, AAA, CTG, AAA, GTG, CCT, GGC, GAA, ACC, CAG, ACC, GGT, AAG, CTG, TTC, CGT, ATG, CGC, GGT, AAA, GGC, GTC, AAG, TCT, GTC, CGC, GGT, GGC, GCA, CAG, GGT, GAT, TTG, CTA, TGC, CGC, GTT, GTT, GTC, GAA, ACA, CCG, GTA, GGT, TTG, AAC, GAG, AAG, CAG, AAA, CAG, CTG, CTG, CAA, GAG, CTG, CAA, GAA, AGC, TTT, GGT, GGC, CCA, ACC, GGC, GAG, CAC, AAC, AGC, CCG, CGT, TCA, AAG, AGC, TTC, TTT, GAT, GGC, GTG, AAG, AAG, TTT, TTT, GAC, GAC, CTG, ACT, CGC, TAA]
+Is Protein?: NO
+
+Region Name: hypothetical protein
+Nucleotides: TTGCTCTTACTCGGATTCGTAAGCCGTGAAAACAGCAACCTCCGTCTGGCCAGTTCGGATGTGAACCTCACAGAGGTCTTTTCTCGTTACCAGCGCCGCCACTACGGCGGTGATACAGATGACGATCAGGGCGACAATCATCGCCTTATGCTGCTTCATTGCTCTCTTCTCCTTGACCTTTCGGTCAGTAAGAGGCACTCTACATGTGTTCTGCATATAGGGGGCCTCGGGTTGATGGTAAAATATCACTCGGGGCTTTTCTCTATCTGCCGTTCAGCTAATGCCTGA
+Nuc. Counts: [58, 78, 69, 83]
+Total Mass%: [21.04, 23.27, 28.0, 27.88] of 37245.0
+Codons List: [TTG, CTC, TTA, CTC, GGA, TTC, GTA, AGC, CGT, GAA, AAC, AGC, AAC, CTC, CGT, CTG, GCC, AGT, TCG, GAT, GTG, AAC, CTC, ACA, GAG, GTC, TTT, TCT, CGT, TAC, CAG, CGC, CGC, CAC, TAC, GGC, GGT, GAT, ACA, GAT, GAC, GAT, CAG, GGC, GAC, AAT, CAT, CGC, CTT, ATG, CTG, CTT, CAT, TGC, TCT, CTT, CTC, CTT, GAC, CTT, TCG, GTC, AGT, AAG, AGG, CAC, TCT, ACA, TGT, GTT, CTG, CAT, ATA, GGG, GGC, CTC, GGG, TTG, ATG, GTA, AAA, TAT, CAC, TCG, GGG, CTT, TTC, TCT, ATC, TGC, CGT, TCA, GCT, AAT, GCC, TGA]
+Is Protein?: NO
+
+Region Name: hypothetical protein
+Nucleotides: ATGTCTGCCAAAAGACGACTTCTTATTGCGTGTACCTTGATAACAGCTATCTATCATTTTCCTGCATATTCTTCATTAGAATATAAAGGATCCTTTGGTTCAATAAATGCGGGTTATGCAGACTGGAATAGTGGATTTGTAAACACTCACCGTGGTGAAGTATGGAAAGTGACTGCGGATTTTGGGGTAAATTTTAAAGAAGCAGAATTTTACTCATTTTATGAAAGTAATGTACTCAATCATGCTGTAGCAGGGAGAAATCATACGGTTTCAGCAATGACGCATGTCAGACTCTTTGACTCTGATATGACATTCTTTGGCAAAATTTATGGCCAATGGGATAACTCATGGGGTGACGATCTGGACATGTTTTATGGATTCGGTTACCTCGGCTGGAACGGCGAGTGGGGCTTTTTTAAACCGTATATTGGATTGCATAATCAATCTGGTGACTACGTATCAGCTAAATATGGTCAAACGAATGGTTGGAATGGTTATGTTGTTGGCTGGACAGCAGTATTACCATTTACGTTATTTGACGAAAAATTTGTTTTATCTAACTGGAATGAAATAGAACTGGACAGGAACGATGCTTACACGGAGCAGCAATTTGGCCGGAACGGGTTAAATGGCGGTTTAACTATTGCCTGGAAGTTCTATCCTCGCTGGAAAGCCAGTGTGACGTGGCGTTATTTCGATAATAAGCTGGGCTACGATGGCTTTGGCGATCAAATGATTTATATGCTTGGTTATGATTTCTAA
+Nuc. Counts: [214, 121, 184, 243]
+Total Mass%: [29.25, 13.6, 28.13, 30.75] of 98860.9
+Codons List: [ATG, TCT, GCC, AAA, AGA, CGA, CTT, CTT, ATT, GCG, TGT, ACC, TTG, ATA, ACA, GCT, ATC, TAT, CAT, TTT, CCT, GCA, TAT, TCT, TCA, TTA, GAA, TAT, AAA, GGA, TCC, TTT, GGT, TCA, ATA, AAT, GCG, GGT, TAT, GCA, GAC, TGG, AAT, AGT, GGA, TTT, GTA, AAC, ACT, CAC, CGT, GGT, GAA, GTA, TGG, AAA, GTG, ACT, GCG, GAT, TTT, GGG, GTA, AAT, TTT, AAA, GAA, GCA, GAA, TTT, TAC, TCA, TTT, TAT, GAA, AGT, AAT, GTA, CTC, AAT, CAT, GCT, GTA, GCA, GGG, AGA, AAT, CAT, ACG, GTT, TCA, GCA, ATG, ACG, CAT, GTC, AGA, CTC, TTT, GAC, TCT, GAT, ATG, ACA, TTC, TTT, GGC, AAA, ATT, TAT, GGC, CAA, TGG, GAT, AAC, TCA, TGG, GGT, GAC, GAT, CTG, GAC, ATG, TTT, TAT, GGA, TTC, GGT, TAC, CTC, GGC, TGG, AAC, GGC, GAG, TGG, GGC, TTT, TTT, AAA, CCG, TAT, ATT, GGA, TTG, CAT, AAT, CAA, TCT, GGT, GAC, TAC, GTA, TCA, GCT, AAA, TAT, GGT, CAA, ACG, AAT, GGT, TGG, AAT, GGT, TAT, GTT, GTT, GGC, TGG, ACA, GCA, GTA, TTA, CCA, TTT, ACG, TTA, TTT, GAC, GAA, AAA, TTT, GTT, TTA, TCT, AAC, TGG, AAT, GAA, ATA, GAA, CTG, GAC, AGG, AAC, GAT, GCT, TAC, ACG, GAG, CAG, CAA, TTT, GGC, CGG, AAC, GGG, TTA, AAT, GGC, GGT, TTA, ACT, ATT, GCC, TGG, AAG, TTC, TAT, CCT, CGC, TGG, AAA, GCC, AGT, GTG, ACG, TGG, CGT, TAT, TTC, GAT, AAT, AAG, CTG, GGC, TAC, GAT, GGC, TTT, GGC, GAT, CAA, ATG, ATT, TAT, ATG, CTT, GGT, TAT, GAT, TTC, TAA]
+Is Protein?: YES
+
+Region Name: putative secreted sulfatase
+Nucleotides: ATGCAGAAAACGTTAATGGCCAGTTTGATCGGCCTTGCAGTTTGCACAGGGAATGCTTTTAGTCCTGCCTTAGCCGCAGAGGCTAAACAACCTAATTTAGTCATTATTATGGCGGATGATTTAGGTTATGGCGATTTAGCAACATATGGTCATCAGATCGTTAAAACACCTAATATCGACAGGCTTGCCCAGGAAGGGGTCAAATTTACTGACTACTATGCCCCCGCTCCTTTAAGTTCACCTTCACGCGCAGGGCTATTAACCGGCCGGATGCCATTTCGTACTGGAATTCGCTCATGGATTCCTTCAGGCAAAGATGTTGCCTTAGGGCGTAACGAACTCACGATTGCTAATCTACTCAAAGCGCAAGGGTACGACACGGCAATGATGGGTAAGCTGCATCTGAATGCAGGCGGCGATCGCACCGATCAGCCACAAGCACAAGATATGGGCTTTGATTACTCACTGGTTAATACGGCGGGCTTTGTTACCGACGCCACGCTGGATAACGCTAAAGAACGCCCGCGTTATGGCATGGTTTACCCGACAGGCTGGCTACGTAACGGGCAACCCACTCCACGAGCTGATAAAATGAGCGGTGAGTATGTCAGTTCGGAAGTCGTCAACTGGCTGGATAACAAAAAGGACAGCAAGCCTTTCTTCCTCTATGTTGCTTTTACCGAAGTGCATAGCCCCCTGGCTTCGCCCAAAAAATACCTCGATATGTACTCACAATATATGAGCGCGTATCAGAAGCAGCATCCTGATTTATTTTATGGCGACTGGGCAGACAAACCCTGGCGTGGTGTGGGGGAATATTATGCCAATATCAGCTATCTGGATGCACAGGTTGGAAAAGTGCTGGATAAAATCAAAGCTGTGGGTGAAGAAGATAACACAATCGTTATTTTTACCAGTGATAACGGTCCGGTAACGCGTGAAGCGCGCAAAGTGTATGAGCTGAATTTGGCAGGGGAAACGGATGGATTACGCGGTCGCAAGGATAACCTTTGGGAAGGCGGAATTCGTGTTCCAGCCATTATTAAATATGGTAAACATCTACCACAGGGAATGGTTTCAGATACACCCGTTTATGGTCTGGACTGGATGCCTACTTTAGCGAAAATGATGAACTTCAAATTACCTACAGACCGTACTTTCGATGGTGAATCGCTGGTTCCTGTTCTTGAGCAAAAAGCATTGAAACGCGAAAAGCCATTAATTTTCGGGATTGATATGCCATTCCAGGATGATCCAACCGATGAATGGGCGATCCGTGATGGTGACTGGAAGATGATTATCGATCGCAATAATAAACCGAAATATCTCTACAATCTGAAATCTGATCGTTATGAAACACTTAATCTGATCGGTAAAAAAACAGATATTGAAAAACAGATGTATGGTAAGTTTTTAAAATATAAAACTGATATTGATAATGATTCTCTAATGAAAGCCAGAGGTGATAAACCAGAAGCGGTGACCTGGGGCTAA
+Nuc. Counts: [440, 312, 362, 380]
+Total Mass%: [30.43, 17.74, 28.0, 24.33] of 195417.1
+Codons List: [ATG, CAG, AAA, ACG, TTA, ATG, GCC, AGT, TTG, ATC, GGC, CTT, GCA, GTT, TGC, ACA, GGG, AAT, GCT, TTT, AGT, CCT, GCC, TTA, GCC, GCA, GAG, GCT, AAA, CAA, CCT, AAT, TTA, GTC, ATT, ATT, ATG, GCG, GAT, GAT, TTA, GGT, TAT, GGC, GAT, TTA, GCA, ACA, TAT, GGT, CAT, CAG, ATC, GTT, AAA, ACA, CCT, AAT, ATC, GAC, AGG, CTT, GCC, CAG, GAA, GGG, GTC, AAA, TTT, ACT, GAC, TAC, TAT, GCC, CCC, GCT, CCT, TTA, AGT, TCA, CCT, TCA, CGC, GCA, GGG, CTA, TTA, ACC, GGC, CGG, ATG, CCA, TTT, CGT, ACT, GGA, ATT, CGC, TCA, TGG, ATT, CCT, TCA, GGC, AAA, GAT, GTT, GCC, TTA, GGG, CGT, AAC, GAA, CTC, ACG, ATT, GCT, AAT, CTA, CTC, AAA, GCG, CAA, GGG, TAC, GAC, ACG, GCA, ATG, ATG, GGT, AAG, CTG, CAT, CTG, AAT, GCA, GGC, GGC, GAT, CGC, ACC, GAT, CAG, CCA, CAA, GCA, CAA, GAT, ATG, GGC, TTT, GAT, TAC, TCA, CTG, GTT, AAT, ACG, GCG, GGC, TTT, GTT, ACC, GAC, GCC, ACG, CTG, GAT, AAC, GCT, AAA, GAA, CGC, CCG, CGT, TAT, GGC, ATG, GTT, TAC, CCG, ACA, GGC, TGG, CTA, CGT, AAC, GGG, CAA, CCC, ACT, CCA, CGA, GCT, GAT, AAA, ATG, AGC, GGT, GAG, TAT, GTC, AGT, TCG, GAA, GTC, GTC, AAC, TGG, CTG, GAT, AAC, AAA, AAG, GAC, AGC, AAG, CCT, TTC, TTC, CTC, TAT, GTT, GCT, TTT, ACC, GAA, GTG, CAT, AGC, CCC, CTG, GCT, TCG, CCC, AAA, AAA, TAC, CTC, GAT, ATG, TAC, TCA, CAA, TAT, ATG, AGC, GCG, TAT, CAG, AAG, CAG, CAT, CCT, GAT, TTA, TTT, TAT, GGC, GAC, TGG, GCA, GAC, AAA, CCC, TGG, CGT, GGT, GTG, GGG, GAA, TAT, TAT, GCC, AAT, ATC, AGC, TAT, CTG, GAT, GCA, CAG, GTT, GGA, AAA, GTG, CTG, GAT, AAA, ATC, AAA, GCT, GTG, GGT, GAA, GAA, GAT, AAC, ACA, ATC, GTT, ATT, TTT, ACC, AGT, GAT, AAC, GGT, CCG, GTA, ACG, CGT, GAA, GCG, CGC, AAA, GTG, TAT, GAG, CTG, AAT, TTG, GCA, GGG, GAA, ACG, GAT, GGA, TTA, CGC, GGT, CGC, AAG, GAT, AAC, CTT, TGG, GAA, GGC, GGA, ATT, CGT, GTT, CCA, GCC, ATT, ATT, AAA, TAT, GGT, AAA, CAT, CTA, CCA, CAG, GGA, ATG, GTT, TCA, GAT, ACA, CCC, GTT, TAT, GGT, CTG, GAC, TGG, ATG, CCT, ACT, TTA, GCG, AAA, ATG, ATG, AAC, TTC, AAA, TTA, CCT, ACA, GAC, CGT, ACT, TTC, GAT, GGT, GAA, TCG, CTG, GTT, CCT, GTT, CTT, GAG, CAA, AAA, GCA, TTG, AAA, CGC, GAA, AAG, CCA, TTA, ATT, TTC, GGG, ATT, GAT, ATG, CCA, TTC, CAG, GAT, GAT, CCA, ACC, GAT, GAA, TGG, GCG, ATC, CGT, GAT, GGT, GAC, TGG, AAG, ATG, ATT, ATC, GAT, CGC, AAT, AAT, AAA, CCG, AAA, TAT, CTC, TAC, AAT, CTG, AAA, TCT, GAT, CGT, TAT, GAA, ACA, CTT, AAT, CTG, ATC, GGT, AAA, AAA, ACA, GAT, ATT, GAA, AAA, CAG, ATG, TAT, GGT, AAG, TTT, TTA, AAA, TAT, AAA, ACT, GAT, ATT, GAT, AAT, GAT, TCT, CTA, ATG, AAA, GCC, AGA, GGT, GAT, AAA, CCA, GAA, GCG, GTG, ACC, TGG, GGC, TAA]
+Is Protein?: YES
+
+Region Name: putative cytoplasmic protein
+Nucleotides: ATGTTTACCAACGTAAATGTTGATTGTTGCAAAACACCAGGATGTAAAAACCTGGGGTTGCTGAATAGCCAGGATTATGTCGCACAGGGTAAAAATATTTTATGCCGTGAATGTGGTTACTTGTTTCCAGTGATATCTGAACAGTCGCTTAATATTTATCGTAATATTGTGAATCACTCCTGGAGAGGTTTGATTTGCCAATGTTCAACTTGCGGAGGCACGTCCCTCAAAAAATATGGATATTCTGCACAAGGCCAGAGAAGAATGTATTGCCATCATTGTGAGAAAACATTTATCACTCTGGAACATGTAATTACCACACCACGAGGAGCCCTGTTAGCATTGATGATTGAGCAAGGGGAGGCACTTGCGGATATCAGAAAGTCATTACGTCTTAACAGCACTGGACTTAGCCGTGAACTGTTAAAATTAGCGCGTGAAGCAAACTATAAAGAAAGTCGACAGTGTTTCCCTGCTTCTGATATTACCCTGAGTACCCGCGCTTTTCGCGTCAAGTATAATGGTAGCAATAACTCTCTTTATGCTCTTGTTACCGCAGAAGAACAAAGCGGCAGGGTGGTTGCCATCTCAACCAATTACTCCCCATCTGCCGTAGAGCAACATTATCAATACACATCGAACTATGAAGAGCGTATGTCTCCAGGGACGCTGGCACATCATGTCCAGCGCAAAGAGTTACTTACTATGCGGCGGGATACCTTGTTTGATATTGATTACGGCCCGGCAGTTTTACATCAAAACGATCCGGGAATGTTGGTAAAACCGGTTCTTCCGGCATATCGTCATTTTGAACTGGTCAGAATACTGACCGATGAGCATTCCAACAACGTTCAGCATTACCTTGATCACGAATGCTTTATATTGGGCGGCTGCCTGATGGCTAATTTGCAGCATATTCATCAAGGTCGCTGCCATATTTCCTTTGTCAAAGAGCGCGGTGTGGCACCCGCCACCATTGATTTTCCACCGCGATTATTCCTTAGTGGTGGGGTACGAAATAATGTCTGGCGTGCATTTTCTAACCGCAATTATTCAATGGCTGTATGCAATCTCACTGGCAGTAAGAAAGTCCGCGAGATGCGGCATGCAACATTGAACAGTGCGACGCGTTTTATCCACTTTGTGGAGAACCATCCTTTCCTTATATCATTGAACCGAATGTCTCCTGCGAATGTCGTTTCTACATTAGATATCCTCAAACATCTGTGGAATAAAAAACTAGAGCATGGAACAATTTAA
+Nuc. Counts: [355, 273, 276, 356]
+Total Mass%: [29.36, 18.56, 25.53, 27.26] of 163388.6
+Codons List: [ATG, TTT, ACC, AAC, GTA, AAT, GTT, GAT, TGT, TGC, AAA, ACA, CCA, GGA, TGT, AAA, AAC, CTG, GGG, TTG, CTG, AAT, AGC, CAG, GAT, TAT, GTC, GCA, CAG, GGT, AAA, AAT, ATT, TTA, TGC, CGT, GAA, TGT, GGT, TAC, TTG, TTT, CCA, GTG, ATA, TCT, GAA, CAG, TCG, CTT, AAT, ATT, TAT, CGT, AAT, ATT, GTG, AAT, CAC, TCC, TGG, AGA, GGT, TTG, ATT, TGC, CAA, TGT, TCA, ACT, TGC, GGA, GGC, ACG, TCC, CTC, AAA, AAA, TAT, GGA, TAT, TCT, GCA, CAA, GGC, CAG, AGA, AGA, ATG, TAT, TGC, CAT, CAT, TGT, GAG, AAA, ACA, TTT, ATC, ACT, CTG, GAA, CAT, GTA, ATT, ACC, ACA, CCA, CGA, GGA, GCC, CTG, TTA, GCA, TTG, ATG, ATT, GAG, CAA, GGG, GAG, GCA, CTT, GCG, GAT, ATC, AGA, AAG, TCA, TTA, CGT, CTT, AAC, AGC, ACT, GGA, CTT, AGC, CGT, GAA, CTG, TTA, AAA, TTA, GCG, CGT, GAA, GCA, AAC, TAT, AAA, GAA, AGT, CGA, CAG, TGT, TTC, CCT, GCT, TCT, GAT, ATT, ACC, CTG, AGT, ACC, CGC, GCT, TTT, CGC, GTC, AAG, TAT, AAT, GGT, AGC, AAT, AAC, TCT, CTT, TAT, GCT, CTT, GTT, ACC, GCA, GAA, GAA, CAA, AGC, GGC, AGG, GTG, GTT, GCC, ATC, TCA, ACC, AAT, TAC, TCC, CCA, TCT, GCC, GTA, GAG, CAA, CAT, TAT, CAA, TAC, ACA, TCG, AAC, TAT, GAA, GAG, CGT, ATG, TCT, CCA, GGG, ACG, CTG, GCA, CAT, CAT, GTC, CAG, CGC, AAA, GAG, TTA, CTT, ACT, ATG, CGG, CGG, GAT, ACC, TTG, TTT, GAT, ATT, GAT, TAC, GGC, CCG, GCA, GTT, TTA, CAT, CAA, AAC, GAT, CCG, GGA, ATG, TTG, GTA, AAA, CCG, GTT, CTT, CCG, GCA, TAT, CGT, CAT, TTT, GAA, CTG, GTC, AGA, ATA, CTG, ACC, GAT, GAG, CAT, TCC, AAC, AAC, GTT, CAG, CAT, TAC, CTT, GAT, CAC, GAA, TGC, TTT, ATA, TTG, GGC, GGC, TGC, CTG, ATG, GCT, AAT, TTG, CAG, CAT, ATT, CAT, CAA, GGT, CGC, TGC, CAT, ATT, TCC, TTT, GTC, AAA, GAG, CGC, GGT, GTG, GCA, CCC, GCC, ACC, ATT, GAT, TTT, CCA, CCG, CGA, TTA, TTC, CTT, AGT, GGT, GGG, GTA, CGA, AAT, AAT, GTC, TGG, CGT, GCA, TTT, TCT, AAC, CGC, AAT, TAT, TCA, ATG, GCT, GTA, TGC, AAT, CTC, ACT, GGC, AGT, AAG, AAA, GTC, CGC, GAG, ATG, CGG, CAT, GCA, ACA, TTG, AAC, AGT, GCG, ACG, CGT, TTT, ATC, CAC, TTT, GTG, GAG, AAC, CAT, CCT, TTC, CTT, ATA, TCA, TTG, AAC, CGA, ATG, TCT, CCT, GCG, AAT, GTC, GTT, TCT, ACA, TTA, GAT, ATC, CTC, AAA, CAT, CTG, TGG, AAT, AAA, AAA, CTA, GAG, CAT, GGA, ACA, ATT, TAA]
+Is Protein?: YES
+
+Region Name: sodium/proton antiporter 1
+Nucleotides: GTGAAACATCTGCATCGATTCTTTAGCAGTGATGCCTCGGGAGGCATTATTCTCATTATTGCCGCTGTATTAGCGATGATTATGGCCAACAGCGGTGCAACCAGTGGATGGTATCACGACTTTCTTGAGACGCCGGTTCAGCTCCGGGTTGGGACACTTGAGATCAACAAGAACATGCTGCTATGGATCAATGACGCTCTGATGGCGGTATTTTTCCTGTTGGTTGGTCTGGAAGTTAAACGCGAGCTGATGCAAGGTTCGCTGGCCAGTCTGCGCCAGGCGGCATTTCCTGTTATTGCCGCAATCGGCGGGATGATTGTCCCGGCATTGCTCTATCTGGCTTTTAACTATGCCGATCCGATTACCCGCGAAGGCTGGGCAATCCCGGCGGCGACTGACATTGCCTTTGCACTTGGTGTGTTGGCGCTGTTGGGAAGTCGTGTTCCGTTAGCGCTGAAGATCTTTTTGATGGCTCTGGCTATTATCGACGATCTTGGGGCCATCATTATCATCGCATTGTTCTACACTAATGACTTATCGATGGCCTCTCTTGGCGTCGCGGCTGTAGCAATTGCGGTACTCGCGGTATTGAATCTGTGTGGTGTACGCCGCACGGGCGTTTATATTCTGGTTGGCGTGGTGCTGTGGACAGCGGTGTTGAAATCGGGGGTTCACGCAACCCTGGCTGGCGTCATTGTCGGCTTCTTTATTCCTTTGAAAGAGAAGCATGGGCGCTCTCCGGCTAAACGTCTGGAGCATGTTTTGCATCCATGGGTGGCGTATCTGATTTTGCCGCTGTTTGCATTTGCTAATGCTGGCGTTTCACTGCAAGGTGTCACGCTGGAAGGTTTGACCTCCATTCTGCCATTAGGGATCATCGCTGGTTTGCTGATTGGCAAGCCACTGGGTATTAGTCTGTTCTGCTGGTTGGCGCTGCGTTTGAAATTGGCACATCTGCCAGAGGGAACGACTTACCAGCAAATTATGGCGGTTGGTATCCTGTGCGGTATCGGTTTTACTATGTCTATCTTTATTGCCAGCCTGGCATTTGGTAGCGTAGATCCAGAACTGATTAACTGGGCAAAATTAGGTATCCTTGTCGGTTCAATTTCTTCGGCGGTAATTGGATATAGCTGGTTACGCGTTCGTTTACGTCCATCAGTTTGA
+Nuc. Counts: [215, 258, 331, 363]
+Total Mass%: [19.15, 18.9, 32.98, 29.94] of 151683.9
+Codons List: [GTG, AAA, CAT, CTG, CAT, CGA, TTC, TTT, AGC, AGT, GAT, GCC, TCG, GGA, GGC, ATT, ATT, CTC, ATT, ATT, GCC, GCT, GTA, TTA, GCG, ATG, ATT, ATG, GCC, AAC, AGC, GGT, GCA, ACC, AGT, GGA, TGG, TAT, CAC, GAC, TTT, CTT, GAG, ACG, CCG, GTT, CAG, CTC, CGG, GTT, GGG, ACA, CTT, GAG, ATC, AAC, AAG, AAC, ATG, CTG, CTA, TGG, ATC, AAT, GAC, GCT, CTG, ATG, GCG, GTA, TTT, TTC, CTG, TTG, GTT, GGT, CTG, GAA, GTT, AAA, CGC, GAG, CTG, ATG, CAA, GGT, TCG, CTG, GCC, AGT, CTG, CGC, CAG, GCG, GCA, TTT, CCT, GTT, ATT, GCC, GCA, ATC, GGC, GGG, ATG, ATT, GTC, CCG, GCA, TTG, CTC, TAT, CTG, GCT, TTT, AAC, TAT, GCC, GAT, CCG, ATT, ACC, CGC, GAA, GGC, TGG, GCA, ATC, CCG, GCG, GCG, ACT, GAC, ATT, GCC, TTT, GCA, CTT, GGT, GTG, TTG, GCG, CTG, TTG, GGA, AGT, CGT, GTT, CCG, TTA, GCG, CTG, AAG, ATC, TTT, TTG, ATG, GCT, CTG, GCT, ATT, ATC, GAC, GAT, CTT, GGG, GCC, ATC, ATT, ATC, ATC, GCA, TTG, TTC, TAC, ACT, AAT, GAC, TTA, TCG, ATG, GCC, TCT, CTT, GGC, GTC, GCG, GCT, GTA, GCA, ATT, GCG, GTA, CTC, GCG, GTA, TTG, AAT, CTG, TGT, GGT, GTA, CGC, CGC, ACG, GGC, GTT, TAT, ATT, CTG, GTT, GGC, GTG, GTG, CTG, TGG, ACA, GCG, GTG, TTG, AAA, TCG, GGG, GTT, CAC, GCA, ACC, CTG, GCT, GGC, GTC, ATT, GTC, GGC, TTC, TTT, ATT, CCT, TTG, AAA, GAG, AAG, CAT, GGG, CGC, TCT, CCG, GCT, AAA, CGT, CTG, GAG, CAT, GTT, TTG, CAT, CCA, TGG, GTG, GCG, TAT, CTG, ATT, TTG, CCG, CTG, TTT, GCA, TTT, GCT, AAT, GCT, GGC, GTT, TCA, CTG, CAA, GGT, GTC, ACG, CTG, GAA, GGT, TTG, ACC, TCC, ATT, CTG, CCA, TTA, GGG, ATC, ATC, GCT, GGT, TTG, CTG, ATT, GGC, AAG, CCA, CTG, GGT, ATT, AGT, CTG, TTC, TGC, TGG, TTG, GCG, CTG, CGT, TTG, AAA, TTG, GCA, CAT, CTG, CCA, GAG, GGA, ACG, ACT, TAC, CAG, CAA, ATT, ATG, GCG, GTT, GGT, ATC, CTG, TGC, GGT, ATC, GGT, TTT, ACT, ATG, TCT, ATC, TTT, ATT, GCC, AGC, CTG, GCA, TTT, GGT, AGC, GTA, GAT, CCA, GAA, CTG, ATT, AAC, TGG, GCA, AAA, TTA, GGT, ATC, CTT, GTC, GGT, TCA, ATT, TCT, TCG, GCG, GTA, ATT, GGA, TAT, AGC, TGG, TTA, CGC, GTT, CGT, TTA, CGT, CCA, TCA, GTT, TGA]
+Is Protein?: NO
+
+Region Name: transcriptional activator protein NhaR
+Nucleotides: ATGAGCATGTCTCATATCAATTACAACCACTTGTATTACTTCTGGCATGTCTACAAAGAAGGTTCTGTGGTTGGCGCAGCGGAGGCGCTTTATTTAACACCACAAACCATTACCGGGCAGATCCGGGCGCTGGAAGAGCGCCTGCAAGGGAAACTATTTAAGCGTAAAGGACGTGGTCTGGAACCCAGCGAACTGGGGGAACTGGTCTATCGCTATGCCGATAAAATGTTCACCTTAAGCCAGGAAATGCTGGATATCGTCAACTATCGCAAAGAGTCCAACTTATTGTTTGATGTTGGTGTGGCAGATGCACTTTCCAAACGTCTGGTCAGCAGTGTTCTGGATGCCGCAGTTGTGGAAGACGAGCAGATCCATCTACGCTGTTTCGAATCGACGCACGAGATGCTTTTAGAGCAGTTGAGTCAGCATAAACTGGATATGATCATCTCTGACTGTCCGATCGATTCCACTCAGCAGGAAGGGCTGTTTTCCATGAAAATTGGCGAATGTGGTGTCAGTTTCTGGTGCACTAACCCACTACCAGAAAAGCCGTTTCCTGCCTGTCTTGAAGAGCGTCGTTTACTTATTCCGGGGCGTCGCTCAATGTTGGGGCGTAAACTATTAAACTGGTTTAACTCCCAGGGCTTGAACGTCGAAATTTTGGGTGAGTTTGATGATGCTGCGTTGATGAAAGCCTTTGGGGCGACGCATAACGCTATTTTCGTTGCACCTTCGCTTTACGCTAATGATTTCTATAACGATGACTCGGTTGTGGAGATAGGCCGTGTTGAGAACGTGATGGAAGAGTACCACGCGATTTTTGCCGAAAGGATGATTCAGCACCCTGCAGTACAGCGTATCTGCAATACAGACTATTCTGCGCTGTTTACTCCAGCTTCAAAATAA
+Nuc. Counts: [228, 197, 232, 249]
+Total Mass%: [26.07, 18.52, 29.67, 26.36] of 118181.6
+Codons List: [ATG, AGC, ATG, TCT, CAT, ATC, AAT, TAC, AAC, CAC, TTG, TAT, TAC, TTC, TGG, CAT, GTC, TAC, AAA, GAA, GGT, TCT, GTG, GTT, GGC, GCA, GCG, GAG, GCG, CTT, TAT, TTA, ACA, CCA, CAA, ACC, ATT, ACC, GGG, CAG, ATC, CGG, GCG, CTG, GAA, GAG, CGC, CTG, CAA, GGG, AAA, CTA, TTT, AAG, CGT, AAA, GGA, CGT, GGT, CTG, GAA, CCC, AGC, GAA, CTG, GGG, GAA, CTG, GTC, TAT, CGC, TAT, GCC, GAT, AAA, ATG, TTC, ACC, TTA, AGC, CAG, GAA, ATG, CTG, GAT, ATC, GTC, AAC, TAT, CGC, AAA, GAG, TCC, AAC, TTA, TTG, TTT, GAT, GTT, GGT, GTG, GCA, GAT, GCA, CTT, TCC, AAA, CGT, CTG, GTC, AGC, AGT, GTT, CTG, GAT, GCC, GCA, GTT, GTG, GAA, GAC, GAG, CAG, ATC, CAT, CTA, CGC, TGT, TTC, GAA, TCG, ACG, CAC, GAG, ATG, CTT, TTA, GAG, CAG, TTG, AGT, CAG, CAT, AAA, CTG, GAT, ATG, ATC, ATC, TCT, GAC, TGT, CCG, ATC, GAT, TCC, ACT, CAG, CAG, GAA, GGG, CTG, TTT, TCC, ATG, AAA, ATT, GGC, GAA, TGT, GGT, GTC, AGT, TTC, TGG, TGC, ACT, AAC, CCA, CTA, CCA, GAA, AAG, CCG, TTT, CCT, GCC, TGT, CTT, GAA, GAG, CGT, CGT, TTA, CTT, ATT, CCG, GGG, CGT, CGC, TCA, ATG, TTG, GGG, CGT, AAA, CTA, TTA, AAC, TGG, TTT, AAC, TCC, CAG, GGC, TTG, AAC, GTC, GAA, ATT, TTG, GGT, GAG, TTT, GAT, GAT, GCT, GCG, TTG, ATG, AAA, GCC, TTT, GGG, GCG, ACG, CAT, AAC, GCT, ATT, TTC, GTT, GCA, CCT, TCG, CTT, TAC, GCT, AAT, GAT, TTC, TAT, AAC, GAT, GAC, TCG, GTT, GTG, GAG, ATA, GGC, CGT, GTT, GAG, AAC, GTG, ATG, GAA, GAG, TAC, CAC, GCG, ATT, TTT, GCC, GAA, AGG, ATG, ATT, CAG, CAC, CCT, GCA, GTA, CAG, CGT, ATC, TGC, AAT, ACA, GAC, TAT, TCT, GCG, CTG, TTT, ACT, CCA, GCT, TCA, AAA, TAA]
+Is Protein?: YES
+
+Region Name: riboflavin kinase
+Nucleotides: ATGAAGCTGATACGCGGCATACATAATCTCAGCCAGGCCCCGCAAGAAGGGTGTGTGCTGACTATTGGTAATTTCGACGGCGTGCATCGCGGTCATCGCGCGCTGTTACAGGGCTTGCAGGAAGAAGGGCGCAAGCGCAACTTACCGGTGATGGTGATGCTTTTTGAACCTCAACCACTGGAACTGTTTGCTACTGATAAAGCCCCGGCACGGCTCACCCGGCTGCGGGAAAAACTGCGTTATCTTGCAGAGTGTGGCGTTGATTACGTGCTGTGCGTGCGTTTTGACAGGCGTTTTGCGGCGTTAACCGCGCAAAACTTCATCAGTGATCTTCTGGTGAAGCACTTGCGGGTAAAATTTCTTGCCGTAGGTGACGATTTCCGCTTTGGCGCTGGTCGTGAAGGCGATTTCTTGTTATTACAGAAAGCGGGCATGGAATACGGCTTCGATATCACCAGCACGCAAACTTTTTGCGAAGGTGGTGTGCGTATCAGCAGCACCGCCGTGCGTCAGGCGCTTGCGGATGACAATCTGGCTCTGGCAGAAAGTTTACTGGGGCACCCGTTTGCTATCTCCGGGCGTGTAGTCCACGGTGATGAATTAGGGCGCACTATAGGTTTCCCGACGGCGAATGTACCGCTACGCCGTCAGGTTTCCCCGGTGAAAGGGGTTTATGCGGTAGAAGTGTTGGGCCTTGGCGAAAAGCCGTTACCCGGCGTTGCAAACATCGGAACACGCCCAACGGTTGCCGGTATTCGCCAGCAACTGGAAGTGCATTTGTTAGATGTTGCAATGGACCTTTATGGTCGCCATATACAAGTAGTGCTGCGTAAAAAAATACGCAATGAGCAGCGATTTGCATCGCTGGACGAACTGAAAGCGCAGATTGCGCGTGATGAATTAACCGCCCGCGAATTTTTTGGGCTAACAAAACCGGCTTAA
+Nuc. Counts: [213, 221, 276, 232]
+Total Mass%: [23.23, 19.81, 33.66, 23.42] of 123918.1
+Codons List: [ATG, AAG, CTG, ATA, CGC, GGC, ATA, CAT, AAT, CTC, AGC, CAG, GCC, CCG, CAA, GAA, GGG, TGT, GTG, CTG, ACT, ATT, GGT, AAT, TTC, GAC, GGC, GTG, CAT, CGC, GGT, CAT, CGC, GCG, CTG, TTA, CAG, GGC, TTG, CAG, GAA, GAA, GGG, CGC, AAG, CGC, AAC, TTA, CCG, GTG, ATG, GTG, ATG, CTT, TTT, GAA, CCT, CAA, CCA, CTG, GAA, CTG, TTT, GCT, ACT, GAT, AAA, GCC, CCG, GCA, CGG, CTC, ACC, CGG, CTG, CGG, GAA, AAA, CTG, CGT, TAT, CTT, GCA, GAG, TGT, GGC, GTT, GAT, TAC, GTG, CTG, TGC, GTG, CGT, TTT, GAC, AGG, CGT, TTT, GCG, GCG, TTA, ACC, GCG, CAA, AAC, TTC, ATC, AGT, GAT, CTT, CTG, GTG, AAG, CAC, TTG, CGG, GTA, AAA, TTT, CTT, GCC, GTA, GGT, GAC, GAT, TTC, CGC, TTT, GGC, GCT, GGT, CGT, GAA, GGC, GAT, TTC, TTG, TTA, TTA, CAG, AAA, GCG, GGC, ATG, GAA, TAC, GGC, TTC, GAT, ATC, ACC, AGC, ACG, CAA, ACT, TTT, TGC, GAA, GGT, GGT, GTG, CGT, ATC, AGC, AGC, ACC, GCC, GTG, CGT, CAG, GCG, CTT, GCG, GAT, GAC, AAT, CTG, GCT, CTG, GCA, GAA, AGT, TTA, CTG, GGG, CAC, CCG, TTT, GCT, ATC, TCC, GGG, CGT, GTA, GTC, CAC, GGT, GAT, GAA, TTA, GGG, CGC, ACT, ATA, GGT, TTC, CCG, ACG, GCG, AAT, GTA, CCG, CTA, CGC, CGT, CAG, GTT, TCC, CCG, GTG, AAA, GGG, GTT, TAT, GCG, GTA, GAA, GTG, TTG, GGC, CTT, GGC, GAA, AAG, CCG, TTA, CCC, GGC, GTT, GCA, AAC, ATC, GGA, ACA, CGC, CCA, ACG, GTT, GCC, GGT, ATT, CGC, CAG, CAA, CTG, GAA, GTG, CAT, TTG, TTA, GAT, GTT, GCA, ATG, GAC, CTT, TAT, GGT, CGC, CAT, ATA, CAA, GTA, GTG, CTG, CGT, AAA, AAA, ATA, CGC, AAT, GAG, CAG, CGA, TTT, GCA, TCG, CTG, GAC, GAA, CTG, AAA, GCG, CAG, ATT, GCG, CGT, GAT, GAA, TTA, ACC, GCC, CGC, GAA, TTT, TTT, GGG, CTA, ACA, AAA, CCG, GCT, TAA]
+Is Protein?: YES
+
+Region Name: Isoleucyl-tRNA synthetase
+Nucleotides: ATGAGTGACTATAAATCAACCCTGAATTTGCCGGAAACAGGGTTCCCGATGCGTGGCGATCTCGCCAAGCGCGAACCGGGAATGCTGGCGCGTTGGACTGATGATGATCTGTACGGCATCATCCGTGCGGCTAAAAAAGGCAAAAAAACCTTCATTCTGCATGATGGCCCTCCTTATGCGAATGGCAGCATTCATATTGGTCACTCGGTTAACAAGATTCTGAAAGACATTATCATTAAGTCCAAAGGGCTTTCTGGATATGACTCGCCGTATGTGCCTGGCTGGGACTGTCATGGTCTGCCAATCGAACTGAAAGTAGAGCAAGAATACGGTAAGCCGGGGGAGAAATTCACCGCCGCTGAGTTCCGCGCCAAGTGCCGCGAATACGCTGCGACCCAGGTTGACGGTCAGCGCAAAGACTTTATCCGTCTGGGCGTGCTGGGCGACTGGTCGCACCCGTACCTGACCATGGACTTCAAAACTGAAGCCAACATCATCCGCGCGCTGGGCAAAATCATCGGCAACGGTCACCTGCACAAAGGCGCGAAGCCGGTGCACTGGTGCGTTGACTGCCGTTCTGCACTGGCAGAAGCGGAAGTTGAGTATTACGACAAAACTTCTCCGTCCATCGACGTCGCTTTCCAGGCGGTCGATCAGGATGCGCTGAAAACGAAATTTGGCGTAAGCAATGTTAACGGCCCAATTTCGCTGGTTATCTGGACCACCACGCCGTGGACGCTGCCTGCTAACCGCGCAATCTCCATTGCACCTGATTTTGATTATGCGCTGGTGCAAATCGACGGTCAGGCCGTGATCCTCGCGAAAGATCTGGTTGAAAGCGTAATGCAGCGTATCGGCGTTAGCGATTACACCATTCTTGGCACGGTGAAAGGTGCCGAGCTGGAACTGTTGCGCTTTACCCATCCGTTTATGGACTTCGATGTTCCGGCAATTCTCGGCGACCACGTTACGCTGGATGCCGGTACCGGTGCCGTTCATACCGCGCCAGGCCACGGTCCGGACGACTATGTGATCGGTCAAAAATATGGTCTGGAAACCGCTAACCCGGTTGGCCCGGACGGCACTTATCTGCCGGGTACTTACCCGACTCTGGATGGCGTTAACGTCTTCAAAGCGAACGATATTGTCATTGCGTTGTTGCAGGAAAAAGGCGCACTGTTGCACGTTGAGAAAATGCAACACAGCTATCCGTGCTGCTGGCGTCATAAAACGCCGATCATCTTCCGCGCGACGCCGCAGTGGTTCGTCAGCATGGATCAGAAAGGTCTGCGTGCGCAGTCACTGAAAGAGATCAAAGGCGTGCAGTGGATCCCTGACTGGGGCCAGGCGCGTATCGAGTCGATGGTTGCTAACCGTCCTGACTGGTGTATCTCTCGTCAGCGTACCTGGGGCGTGCCGATGTCACTGTTCGTGCACAAAGACACAGAAGAACTGCATCCGCGTACTCTCGAACTGATGGAAGAAGTGGCAAAACGCGTTGAAGTTGACGGCATTCAGGCGTGGTGGGATCTCGATGCGAAAGAGATCCTCGGCGACGAAGCTGACCAGTATGTGAAAGTACCGGATACGCTGGATGTATGGTTTGACTCCGGATCTACCCACTCTTCCGTTGTTGATGTGCGTCCGGAATTTGCCGGTCACGCAGCGGACATGTATCTGGAAGGTTCTGACCAACACCGTGGCTGGTTCATGTCTTCCCTGATGATCTCTACCGCGATGAAGGGCAAAGCGCCATATCGTCAGGTACTGACTCACGGCTTTACCGTGGATGGTCAGGGTCGCAAGATGTCTAAATCCATCGGTAACACCGTTTCGCCGCAGGATGTGATGAATAAACTGGGTGCGGATATTCTGCGTCTGTGGGTGGCATCAACCGACTACACTGGCGAAATGGCCGTTTCTGACGAGATCCTGAAACGTGCTGCCGACAGCTATCGTCGTATCCGTAACACCGCGCGCTTCCTGCTGGCAAACCTGAACGGTTTTGATCCGGCAAAAGATATGGTGAAACCGGAAGAGATGGTGGTACTGGATCGCTGGGCCGTAGGTTGTGCGAAAGCGGCACAGGAAGACATCCTCAAGGCGTACGAAGCATACGATTTCCACGAAGTGGTACAGCGTCTGATGCGCTTCTGCTCCGTTGAGATGGGTTCCTTCTACCTCGACATCATCAAAGACCGTCAGTATACCGCCAAAGCGGACAGCGTGGCGCGTCGTAGCTGCCAGACTGCGCTGTATCACATCGCAGAAGCGCTGGTTCGCTGGATGGCACCAATCCTCTCCTTCACCGCTGATGAAGTGTGGGGTTACCTGCCGGGCGAACGTGAAAAATACGTCTTCACCGGCGAGTGGTACGAAGGCCTGTTTGGTCTGGCAGACAGTGAAGCAATGAACGATGCGTTCTGGGACGAGCTGTTGAAAGTGCGTGGCGAAGTGAACAAAGTCATTGAGCAAGCGCGTGCCGATAAGAACGTGGGCGGCTCGCTGGAAGCGGCAGTAACCTTGTATGCAGAACCGGAACTGGCGGCGAAACTGACCGCGCTGGGCGATGAATTACGATTTGTCCTGTTGACCTCCGGCGCTACCGTTGCAGACTATAACGACGCACCTGCTGATGCCCAGCAGAGCGAAGTCCTCAAAGGGCTGAAAGTCGCGTTGAGTAAAGCCGAAGGTGAGAAGTGTCCTCGCTGCTGGCACTACACCCAGGATGTCGGCAAGGTGGCGGAACACGCAGAAATCTGCGGCCGCTGTGTCAGCAACGTCGCCGGTGACGGTGAAAAACGTAAGTTTGCCTGA
+Nuc. Counts: [660, 720, 817, 620]
+Total Mass%: [24.0, 21.53, 33.23, 20.87] of 371617.0
+Codons List: [ATG, AGT, GAC, TAT, AAA, TCA, ACC, CTG, AAT, TTG, CCG, GAA, ACA, GGG, TTC, CCG, ATG, CGT, GGC, GAT, CTC, GCC, AAG, CGC, GAA, CCG, GGA, ATG, CTG, GCG, CGT, TGG, ACT, GAT, GAT, GAT, CTG, TAC, GGC, ATC, ATC, CGT, GCG, GCT, AAA, AAA, GGC, AAA, AAA, ACC, TTC, ATT, CTG, CAT, GAT, GGC, CCT, CCT, TAT, GCG, AAT, GGC, AGC, ATT, CAT, ATT, GGT, CAC, TCG, GTT, AAC, AAG, ATT, CTG, AAA, GAC, ATT, ATC, ATT, AAG, TCC, AAA, GGG, CTT, TCT, GGA, TAT, GAC, TCG, CCG, TAT, GTG, CCT, GGC, TGG, GAC, TGT, CAT, GGT, CTG, CCA, ATC, GAA, CTG, AAA, GTA, GAG, CAA, GAA, TAC, GGT, AAG, CCG, GGG, GAG, AAA, TTC, ACC, GCC, GCT, GAG, TTC, CGC, GCC, AAG, TGC, CGC, GAA, TAC, GCT, GCG, ACC, CAG, GTT, GAC, GGT, CAG, CGC, AAA, GAC, TTT, ATC, CGT, CTG, GGC, GTG, CTG, GGC, GAC, TGG, TCG, CAC, CCG, TAC, CTG, ACC, ATG, GAC, TTC, AAA, ACT, GAA, GCC, AAC, ATC, ATC, CGC, GCG, CTG, GGC, AAA, ATC, ATC, GGC, AAC, GGT, CAC, CTG, CAC, AAA, GGC, GCG, AAG, CCG, GTG, CAC, TGG, TGC, GTT, GAC, TGC, CGT, TCT, GCA, CTG, GCA, GAA, GCG, GAA, GTT, GAG, TAT, TAC, GAC, AAA, ACT, TCT, CCG, TCC, ATC, GAC, GTC, GCT, TTC, CAG, GCG, GTC, GAT, CAG, GAT, GCG, CTG, AAA, ACG, AAA, TTT, GGC, GTA, AGC, AAT, GTT, AAC, GGC, CCA, ATT, TCG, CTG, GTT, ATC, TGG, ACC, ACC, ACG, CCG, TGG, ACG, CTG, CCT, GCT, AAC, CGC, GCA, ATC, TCC, ATT, GCA, CCT, GAT, TTT, GAT, TAT, GCG, CTG, GTG, CAA, ATC, GAC, GGT, CAG, GCC, GTG, ATC, CTC, GCG, AAA, GAT, CTG, GTT, GAA, AGC, GTA, ATG, CAG, CGT, ATC, GGC, GTT, AGC, GAT, TAC, ACC, ATT, CTT, GGC, ACG, GTG, AAA, GGT, GCC, GAG, CTG, GAA, CTG, TTG, CGC, TTT, ACC, CAT, CCG, TTT, ATG, GAC, TTC, GAT, GTT, CCG, GCA, ATT, CTC, GGC, GAC, CAC, GTT, ACG, CTG, GAT, GCC, GGT, ACC, GGT, GCC, GTT, CAT, ACC, GCG, CCA, GGC, CAC, GGT, CCG, GAC, GAC, TAT, GTG, ATC, GGT, CAA, AAA, TAT, GGT, CTG, GAA, ACC, GCT, AAC, CCG, GTT, GGC, CCG, GAC, GGC, ACT, TAT, CTG, CCG, GGT, ACT, TAC, CCG, ACT, CTG, GAT, GGC, GTT, AAC, GTC, TTC, AAA, GCG, AAC, GAT, ATT, GTC, ATT, GCG, TTG, TTG, CAG, GAA, AAA, GGC, GCA, CTG, TTG, CAC, GTT, GAG, AAA, ATG, CAA, CAC, AGC, TAT, CCG, TGC, TGC, TGG, CGT, CAT, AAA, ACG, CCG, ATC, ATC, TTC, CGC, GCG, ACG, CCG, CAG, TGG, TTC, GTC, AGC, ATG, GAT, CAG, AAA, GGT, CTG, CGT, GCG, CAG, TCA, CTG, AAA, GAG, ATC, AAA, GGC, GTG, CAG, TGG, ATC, CCT, GAC, TGG, GGC, CAG, GCG, CGT, ATC, GAG, TCG, ATG, GTT, GCT, AAC, CGT, CCT, GAC, TGG, TGT, ATC, TCT, CGT, CAG, CGT, ACC, TGG, GGC, GTG, CCG, ATG, TCA, CTG, TTC, GTG, CAC, AAA, GAC, ACA, GAA, GAA, CTG, CAT, CCG, CGT, ACT, CTC, GAA, CTG, ATG, GAA, GAA, GTG, GCA, AAA, CGC, GTT, GAA, GTT, GAC, GGC, ATT, CAG, GCG, TGG, TGG, GAT, CTC, GAT, GCG, AAA, GAG, ATC, CTC, GGC, GAC, GAA, GCT, GAC, CAG, TAT, GTG, AAA, GTA, CCG, GAT, ACG, CTG, GAT, GTA, TGG, TTT, GAC, TCC, GGA, TCT, ACC, CAC, TCT, TCC, GTT, GTT, GAT, GTG, CGT, CCG, GAA, TTT, GCC, GGT, CAC, GCA, GCG, GAC, ATG, TAT, CTG, GAA, GGT, TCT, GAC, CAA, CAC, CGT, GGC, TGG, TTC, ATG, TCT, TCC, CTG, ATG, ATC, TCT, ACC, GCG, ATG, AAG, GGC, AAA, GCG, CCA, TAT, CGT, CAG, GTA, CTG, ACT, CAC, GGC, TTT, ACC, GTG, GAT, GGT, CAG, GGT, CGC, AAG, ATG, TCT, AAA, TCC, ATC, GGT, AAC, ACC, GTT, TCG, CCG, CAG, GAT, GTG, ATG, AAT, AAA, CTG, GGT, GCG, GAT, ATT, CTG, CGT, CTG, TGG, GTG, GCA, TCA, ACC, GAC, TAC, ACT, GGC, GAA, ATG, GCC, GTT, TCT, GAC, GAG, ATC, CTG, AAA, CGT, GCT, GCC, GAC, AGC, TAT, CGT, CGT, ATC, CGT, AAC, ACC, GCG, CGC, TTC, CTG, CTG, GCA, AAC, CTG, AAC, GGT, TTT, GAT, CCG, GCA, AAA, GAT, ATG, GTG, AAA, CCG, GAA, GAG, ATG, GTG, GTA, CTG, GAT, CGC, TGG, GCC, GTA, GGT, TGT, GCG, AAA, GCG, GCA, CAG, GAA, GAC, ATC, CTC, AAG, GCG, TAC, GAA, GCA, TAC, GAT, TTC, CAC, GAA, GTG, GTA, CAG, CGT, CTG, ATG, CGC, TTC, TGC, TCC, GTT, GAG, ATG, GGT, TCC, TTC, TAC, CTC, GAC, ATC, ATC, AAA, GAC, CGT, CAG, TAT, ACC, GCC, AAA, GCG, GAC, AGC, GTG, GCG, CGT, CGT, AGC, TGC, CAG, ACT, GCG, CTG, TAT, CAC, ATC, GCA, GAA, GCG, CTG, GTT, CGC, TGG, ATG, GCA, CCA, ATC, CTC, TCC, TTC, ACC, GCT, GAT, GAA, GTG, TGG, GGT, TAC, CTG, CCG, GGC, GAA, CGT, GAA, AAA, TAC, GTC, TTC, ACC, GGC, GAG, TGG, TAC, GAA, GGC, CTG, TTT, GGT, CTG, GCA, GAC, AGT, GAA, GCA, ATG, AAC, GAT, GCG, TTC, TGG, GAC, GAG, CTG, TTG, AAA, GTG, CGT, GGC, GAA, GTG, AAC, AAA, GTC, ATT, GAG, CAA, GCG, CGT, GCC, GAT, AAG, AAC, GTG, GGC, GGC, TCG, CTG, GAA, GCG, GCA, GTA, ACC, TTG, TAT, GCA, GAA, CCG, GAA, CTG, GCG, GCG, AAA, CTG, ACC, GCG, CTG, GGC, GAT, GAA, TTA, CGA, TTT, GTC, CTG, TTG, ACC, TCC, GGC, GCT, ACC, GTT, GCA, GAC, TAT, AAC, GAC, GCA, CCT, GCT, GAT, GCC, CAG, CAG, AGC, GAA, GTC, CTC, AAA, GGG, CTG, AAA, GTC, GCG, TTG, AGT, AAA, GCC, GAA, GGT, GAG, AAG, TGT, CCT, CGC, TGC, TGG, CAC, TAC, ACC, CAG, GAT, GTC, GGC, AAG, GTG, GCG, GAA, CAC, GCA, GAA, ATC, TGC, GGC, CGC, TGT, GTC, AGC, AAC, GTC, GCC, GGT, GAC, GGT, GAA, AAA, CGT, AAG, TTT, GCC, TGA]
+Is Protein?: YES
+
+Region Name: Non-protein region
+Nucleotides: GCTTGCGCCAACGCCATTTCATCGCCATCCCGCCGAGCATACAGGCCTCGGAAGAACCAATGGTGTTGGTGCCAACGGCCTGACCATTTTTCGGTGCAGGCGCATGCCACAGATCGGCAACCATGTTTACGCAACGCAGATCGATTGCTGCAGATTGCGGATATTCTTCTTTGTCGATCCAGTTTTTGTTAATGGATAAATCCA
+Nuc. Counts: [46, 56, 49, 53]
+Total Mass%: [23.44, 23.46, 27.93, 25.01] of 26515.7
+Codons List: [GCT, TGC, GCC, AAC, GCC, ATT, TCA, TCG, CCA, TCC, CGC, CGA, GCA, TAC, AGG, CCT, CGG, AAG, AAC, CAA, TGG, TGT, TGG, TGC, CAA, CGG, CCT, GAC, CAT, TTT, TCG, GTG, CAG, GCG, CAT, GCC, ACA, GAT, CGG, CAA, CCA, TGT, TTA, CGC, AAC, GCA, GAT, CGA, TTG, CTG, CAG, ATT, GCG, GAT, ATT, CTT, CTT, TGT, CGA, TCC, AGT, TTT, TGT, TAA, TGG, ATA, AAT, CCA]
+Is Protein?: NO
+
+Region Name: FKBP-type 16 kDa peptidyl-prolyl cis-trans isomerase
+Nucleotides: ATGTCTGAATCTGTACAGAGCAATAGCGCCGTCCTGGTGCACTTCACGCTAAAACTCGACGATGGCACCACCGCTGAGTCTACCCGCAACAACGGTAAACCGGCGCTGTTCCGCCTGGGTGATGCTTCTCTTTCTGAAGGGCTGGAGCAACACCTGCTGGGGCTGAAAGTGGGCGATAAAACCACCTTCTCGCTGGAGCCAGATGCGGCGTTTGGCGTGCCGTCACCGGACCTGATTCAGTACTTCTCCCGCCGTGAATTTATGGATGCAGGCGAGCCAGAAATTGGCGCAATCATGCTTTTTACCGCAATGGATGGCAGTGAGATGCCTGGCGTGATCCGCGAAATTAACGGCGACTCCATTACCGTTGATTTCAACCATCCGCTGGCCGGGCAGACCGTTCATTTTGATATTGAAGTGCTGGAAATCGATCCGGCACTGGAGGCGTAA
+Nuc. Counts: [100, 121, 125, 104]
+Total Mass%: [22.87, 22.75, 31.97, 22.02] of 59096.4
+Codons List: [ATG, TCT, GAA, TCT, GTA, CAG, AGC, AAT, AGC, GCC, GTC, CTG, GTG, CAC, TTC, ACG, CTA, AAA, CTC, GAC, GAT, GGC, ACC, ACC, GCT, GAG, TCT, ACC, CGC, AAC, AAC, GGT, AAA, CCG, GCG, CTG, TTC, CGC, CTG, GGT, GAT, GCT, TCT, CTT, TCT, GAA, GGG, CTG, GAG, CAA, CAC, CTG, CTG, GGG, CTG, AAA, GTG, GGC, GAT, AAA, ACC, ACC, TTC, TCG, CTG, GAG, CCA, GAT, GCG, GCG, TTT, GGC, GTG, CCG, TCA, CCG, GAC, CTG, ATT, CAG, TAC, TTC, TCC, CGC, CGT, GAA, TTT, ATG, GAT, GCA, GGC, GAG, CCA, GAA, ATT, GGC, GCA, ATC, ATG, CTT, TTT, ACC, GCA, ATG, GAT, GGC, AGT, GAG, ATG, CCT, GGC, GTG, ATC, CGC, GAA, ATT, AAC, GGC, GAC, TCC, ATT, ACC, GTT, GAT, TTC, AAC, CAT, CCG, CTG, GCC, GGG, CAG, ACC, GTT, CAT, TTT, GAT, ATT, GAA, GTG, CTG, GAA, ATC, GAT, CCG, GCA, CTG, GAG, GCG, TAA]
+Is Protein?: YES
+

src/main/java/com/matthewjensen/project/modules/dna/spec/dna.txt

@@ -0,0 +1,18 @@
+cure for cancer protein
+ATGCCACTATGGTAG
+captain picard hair growth protein
+ATgCCAACATGgATGCCcGATAtGGATTgA
+bogus protein
+CCATtAATgATCaCAGTt
+michael jordan mad hops protein
+ATgAGATCCgtgatGTGggaTCCTaCTCATTaa
+paris hilton phony protein
+AtgCCaacaTGGATGCCCTAAGATAtgGATTagtgA
+george w bush approval rating protein
+atgataattagttttaatatcagactgtaa
+jimi hendrix guitar talent protein
+ATGCAATTGCTCGATTAG
+tyler durden's brain protein
+ATGATAcctatgagtaaTGTGGACCatatccaaACTATAGGCATtgtcggACCAACGATcgattggtTATACTGA
+mini me growth hormone
+AtGgGaCGCTgA

src/main/java/com/matthewjensen/project/modules/dna/spec/dna_console.txt

@@ -0,0 +1,5 @@
+This program reports information about DNA
+nucleotide sequences that may encode proteins.
+
+Input file name? dna.txt
+Output file name? dna_file.txt

src/main/java/com/matthewjensen/project/modules/dna/spec/dna_file.txt

@@ -0,0 +1,63 @@
+Region Name: cure for cancer protein
+Nucleotides: ATGCCACTATGGTAG
+Nuc. Counts: [4, 3, 4, 4]
+Total Mass%: [27.3, 16.8, 30.6, 25.3] of 1978.8
+Codons List: [ATG, CCA, CTA, TGG, TAG]
+Is Protein?: YES
+
+Region Name: captain picard hair growth protein
+Nucleotides: ATGCCAACATGGATGCCCGATATGGATTGA
+Nuc. Counts: [9, 6, 8, 7]
+Total Mass%: [30.7, 16.8, 30.5, 22.1] of 3967.5
+Codons List: [ATG, CCA, ACA, TGG, ATG, CCC, GAT, ATG, GAT, TGA]
+Is Protein?: YES
+
+Region Name: bogus protein
+Nucleotides: CCATTAATGATCACAGTT
+Nuc. Counts: [6, 4, 2, 6]
+Total Mass%: [35.1, 19.3, 13.1, 32.5] of 2308.1
+Codons List: [CCA, TTA, ATG, ATC, ACA, GTT]
+Is Protein?: NO
+
+Region Name: michael jordan mad hops protein
+Nucleotides: ATGAGATCCGTGATGTGGGATCCTACTCATTAA
+Nuc. Counts: [9, 6, 8, 10]
+Total Mass%: [28.0, 15.3, 27.8, 28.8] of 4342.9
+Codons List: [ATG, AGA, TCC, GTG, ATG, TGG, GAT, CCT, ACT, CAT, TAA]
+Is Protein?: YES
+
+Region Name: paris hilton phony protein
+Nucleotides: ATGCCAACATGGATGCCCTAAGATATGGATTAGTGA
+Nuc. Counts: [12, 6, 9, 9]
+Total Mass%: [34.0, 14.0, 28.5, 23.6] of 4774.3
+Codons List: [ATG, CCA, ACA, TGG, ATG, CCC, TAA, GAT, ATG, GAT, TAG, TGA]
+Is Protein?: YES
+
+Region Name: george w bush approval rating protein
+Nucleotides: ATGATAATTAGTTTTAATATCAGACTGTAA
+Nuc. Counts: [12, 2, 4, 12]
+Total Mass%: [41.1, 5.6, 15.3, 38.0] of 3949.5
+Codons List: [ATG, ATA, ATT, AGT, TTT, AAT, ATC, AGA, CTG, TAA]
+Is Protein?: NO
+
+Region Name: jimi hendrix guitar talent protein
+Nucleotides: ATGCAATTGCTCGATTAG
+Nuc. Counts: [5, 3, 4, 6]
+Total Mass%: [28.6, 14.1, 25.6, 31.8] of 2364.1
+Codons List: [ATG, CAA, TTG, CTC, GAT, TAG]
+Is Protein?: YES
+
+Region Name: tyler durden's brain protein
+Nucleotides: ATGATACCTATGAGTAATGTGGACCATATCCAAACTATAGGCATTGTCGGACCAACGATCGATTGGTTATACTGA
+Nuc. Counts: [24, 14, 16, 21]
+Total Mass%: [32.9, 15.8, 24.6, 26.7] of 9843.8
+Codons List: [ATG, ATA, CCT, ATG, AGT, AAT, GTG, GAC, CAT, ATC, CAA, ACT, ATA, GGC, ATT, GTC, GGA, CCA, ACG, ATC, GAT, TGG, TTA, TAC, TGA]
+Is Protein?: YES
+
+Region Name: mini me growth hormone
+Nucleotides: ATGGGACGCTGA
+Nuc. Counts: [3, 2, 5, 2]
+Total Mass%: [24.8, 13.6, 46.3, 15.3] of 1633.4
+Codons List: [ATG, GGA, CGC, TGA]
+Is Protein?: NO
+

src/main/java/com/matthewjensen/project/modules/dna/spec/ecoli.txt

@@ -0,0 +1,40 @@
+thr operon leader peptide
+ATGAAACGCATTAGCaCCAcCATtACCACCaCCATCaCcATTACCACAGGTAACGGTGCGGGCTGA
+aspartokinase I/homoserine dehydrogenase I
+ATGCGAGtGTTGAAGTTcgGCGGTaCATCAgTGGCAAATGCAGAACGTtTTCTGCGGgTTGCCGATAttCTGGAAAGcAATGCCAGGCAGGGGCAGgTGGcCACCGTCCTCtCTGcCCCCGCCAAAATCACCAACCATCtGGTaGCGATGATtGaaAAaACCATtAGCGGTCAGGAtGCtTTaCcCaATATCAGCGATGCCGAACGTATTTTTGCCGAACTtCTGACgGGACTCGCCGCcGCCCAGcCGGGATTTCCGCTGGCACAAtTgAAAAcTTTCGTCGACCAgGAATTTGCCCAAATAAAACATGTcCtGCATGGCatCAGTTTGTTGGGGCAGTGCCCGGaTAGCATcAACGCTGCGCTGATTTGcCGTGgCGAGAAAaTGTcGaTcgCCattaTGGCCGGCGTGTTAGAAGCGCGTGGTCACAACGTTACCGTTATCGATCCGgTCGAAaAAcTGCTgGCAGTGGGTCATTAcCtCgAaTCTACCGTTGATaTtGCTGAATCCACCCGCCGTATTGCGGCAAGCCGCATTCCgGCTGACCACATgGtGCTGATGGCTGGTTTCACTGcCggTAATGAAAAAGgCGaGCTGGtGGTtCTGGGAcGCAACGGTTCCGACTaCTCCGCTGCGGTgCTGGCGGCcTGTTTaCGCGCCGATTGTTGcGAgaTCTGGACGGATGTTGAcGGTGTTTATACCTGCGATCCGCGTCAGGTGCCCGATGCGAGGTTGTTGAAGTCGATGTCCTATCAGgAaGCGATGGAGCTTTCTTACTTCGGCGCTAAAgTTCTTCaCCCcCGCACCATTACCCCCATcGCCCAGtTCCAGATcCCTtgCCtGATTAAAAATAcCGgAAAtCCCCAAGCACCAGgTACGCtCATTGGTGCCAGCCGTGATGAAGACGAATTACCGGTCAAGGGCATTTCCAATcTGAATaACATGGCAATgTTCAGcGTTTCCGgCCCGGGGAtGAAAGGgATggTTgGCATGGCGGCGCGcgTCTTTGCAGcGaTGTCACGCGCCCGTaTTtCCGTGGTgCtGATTACGCAATCATCTTCCGAATACAGTATCAGTTTCTGCGTTCCGCaAAGCGACTGTGTGCGAGCTgAaCGGGCAaTGcAGGAAGAGtTCTACCTGGAaCTGaAAGAAGGCTTACTGGAGCcGTTGGCgGtGACGGAACGGCTGGCCATTATCTcGGTGgTAGGTGATGGTATGCGcACCTtaCGTGGGAtCTCGgCGAAATtCTtTGCCGCGCTgGCcCGCGCCAATATCAACATTGTCgCCATTGCtCaGGGaTCTTcTGAaCGCTCAAtCTCTGTcGTGGTcAaTAACGATgATGCGACCACTGGCGTGCGCGTTACTCATCAGATGCTGTTCAATACCGATCAGGTTATCGAAGTGTTTGTGATTGgCGTCGGTGGCGTTGgcGGTGCGCTGCTGgAGCAACTGAAGCGTCAgCAAAGCTGGTTGAAGAATAAaCATATCGaCTTACGTGTCTGCGGTGTTGCTAACTCGAAGgCACtgCTCACCAATGTACATGGCCTTAATCTGGAAAACTGGCAGgAAGAACTGGCGCAAGCcAAAGAGCCGTTTAATCTCGgGCGcTtAATTCGCCTCGTGAAAGAATATCATCTGCtGAaCCCGGTCATTgTTGACTgTACTTCCAgCCAGGCTGTgGCAGaTCAATATgCCGACTtCCTgCGCGAAGGTTTCCAcGTTGTtACGCCGAaCAAAaAGGCCaACACCTCGTcgATGGaTTACTaCCATCAGTtGCGTTATGCGGCGGAAAAATCGCGGCGTAaATTCCTCtATGACACcaACGTtGGGGCTGGATTACCGGTTATTgAGAACCTGCAAAATCTGCTCAATGCtGGTGATGAATTGATGAAGTTCTCCGGCATTCTTTCAGGTTCGCTTTCTTAtATCTTCGGCAAGTTAGACGAAGGCaTGAGTtTCTCCGAGgCGACCaCACTGGCGCGGGAAATGgGTTATACCGAACCGGAcCcGCGAGATGATCTTtCtGGTATGgAtGTGGCGCgTAagCTAtTGATtCTCGCTCGTGAAACGGGACGTGAACTGGAGCtGGCGGATATTGAAATTGAACCTgTGCTGCCCGCaGaGTTTAACGCCGAGGGTGATGTCGCcGCTTTTATGGCGAATCTGTCACAGCTCGACGaTCtCTTTGCCGCGCGTGTgGCGAAGGCCCGTGATGAAGGAAAAGTTTTGCGCTATGTTGGCAATAttGATGAAGATgGCgTCTGCCGCGTGAAGaTTGCCGAAGTGGATGgTAATGaTCCGCTGTTCAAAGTGAaAaATGGCGaAAACGCCCTGGCCTTCTATAGCCACTATtATCAGCCGCTGCCGTTGGTACTGCGCGGATATGGTGCGGGCaATgACGTTaCAGCTGCCGGTgTCTTTGCTGATCTGCTACGtACCCTcTCAtGGaAGTTAGGAGTCTGA
+homoserine kinase
+ATgGTTAAAgTTTAtGCCCCGGCtTCCAGTGCCaATATGaGcGTCGgGTTTGATGTGCTCGGGgCGGCGGTGACACCTGTTGATGGTGCATTGCTCGgAGaTGTagTcaCGGTTGAGGCGGCAGAGACaTTCAgTCTCAACAACCTCGGACGCTTTGCCGAtAAGCTGCCGTCAGAGCCACGgGaaAATAtCGTTtATcAGTGcTGGGAGCGTtTTTGcCaGGAGCTTGGCAAGCAAATTCCAGTGGCGATGaCTCTGGAAAAGAATatGCCGAtCgGTTCGGGcTTAGGCTcCAGCGCCtGTTCAGTGGTCGCGGCgCTgAtGGCGATgAATGAAcACTGCGGCaAGCCGCTTAATGACACTCGTTTGCTGGCTTtGATGGgCGAgTTGGAAGGGcGTATCTCCGGCAGCAtTCATTACGACAACGtGGCACCGTGtTtTCtTGGTGGTAtGCAGTtgATGATCGAAGAaAACGACATCATCAGCCAGCAaGTGCCAGGGTTTGATGAGtGGCTGTGGGTGCTGGCGTATcCGGgGAtTAAAGTCtCGaCGGcAGAAGCCAGGGCTaTTTTACCGGCGCAGTATCGCCGCCAGGATTGCATTGCGCAcGGGCgACATCTgGCAGGCTTCATTCACGCCTGCTATTCCCGTCAGCTTGAGCTTGCCGCGAAGCTGATgAAAGaTGTTATCGCTGAACCCTACcGTGaACgGTTaCTGCCAGGCTTCCGGCAGGCGCGGcAGgCGGTTGCGGAAATCGGCGCGGTAgCGAGCGGTATCTCCGGCTCCGGCCCGAcTtTGTTCGCTCTGTGtGAcAAGCCGGATACCGCCCAGCGCGTTGCCGACTGgTTGGGTAAGAACtAcCTGCAAAATCAGgAAGGTTTTGTTcATATTTGCCGGCTGGATACGGCGGGcGCACGAgTACTGGAAAACTAA
+threonine synthase
+ATGAAACTCtacaATCTGAAAGATCACAATGAGCAGgTCaGCTTTGCGCAAGCCGTAACCCAGgGgTTAGGCAAAAATCAGGGgCtGTtTTTTCcgCACgaCCTGCCGGaaTTCAGCcTgACTGAAaTTGATGAGATgCTGAAGCtGGATTTTGTCACcCGCAGTGCGAAGATCCTcTCgGCGTTTATTGGTGATGAAATCCCGCAGGAAaTCCTGGAAGAGCGCGTACGTGCGGCGTTTGCCTTCCCGGCTCCGGTCGCCAATGTTGAAaGCGATGTCGGTtGTCTGGAaTTGTTCcACGGGCcAACGCTGGCaTTTAAAGATTTCGGcGGTcGCTTTATGGCACAAATGCTgACCcATATTGCGGGCGATAAGCCAGTGAcCATTCTGACCGCGACATCCGGTgATACTGGaGCGGCAGTGGcTCATGcTTTCtACGGTtTACCGAATGTGAAAGTGGTTATCCTCTATCCACGAGGCAAAATCAGTCCACTGCAAGAAAAACTgTTCTGTACATTGgGCggCAATATCGaAACTGTTGCCATCGAcggCGaTTTCGATGCCTGTCAGGCGCTGGTgAAGCAGGCgTTTGATGATGAAGAACTGAAAGTGgCgCtGGGGCtGAATTCTGCTAAcTCCATCAACaTCAGTCGCTTGCTGGCGcAGATTTGTTaTTAcTTTGaGGCTGTCGCACAGTtGCCGCAAGAAGCACGTAACCAGTTGgTTGTCTCGGTaCCGAGTGgAAACtTcGGCGATtTGACGGcGGGTCTGCTGGCGAaGTcACTCGGTCtGCCGGTAAAACGTtTTATTGCtgCGACCAACGTGAACGAtACCGTACCACGTTTCCTGCaCGaCGGTCAGTGGTCAcCCAAaGCGACTCAGgCGAcgTtaTCCAATGCGATGGATGTTAGCCAGCcAAaCAACTGGCCGCGTGTGGAAGAGTTGtTCcGCCGCAAAATCTGGCAACTGAAAGAGCTGGgTTATGCAGCCGTGgATGATGAAACCACGCAACAGACAATGcGTGAGtTAAaAGAACTGGGCTATACCTCGgAGCCGCACgCTGCCGTAGCTTATCGTGCGCTGCGTGACCAgTTGAAtCCAGGCGAATATGGCTTGTtCCTCGGcACcGCGCATCcGGcGAAatTtAAAgAGAGCGTGGAAGCGATTCTCGGTGAAAcGTTGGatCTGCCAAAAGAGCTGGCAGAACGTGCTgATTTACCCTTGCTTTCGCATAACCTGCCCGCCGATTTTGCTGCGTTGCGTAAatTgaTGATGAaTCATCAGTAA
+hypothetical protein
+AtGCAGCCcGGCTtTTTTTATGAAGAAAATaTGGAGaAaAACGACagGGAAAAAGGAGAAATTCtCAATAAATGCGGtAACTTAGAgATTaGGATTGCGGAGAATaACAACTGCcGTTCTCaTCGCGTAATCTCCGGATATCGACCCaTAACGGgCAATGATAAAAGgAGTAACCTGTGA
+Non-protein region
+aAAAACTgCTGGAAACAATGAAAGAcGTACCGGACGACCAAcGTCAGgCGC
+transaldolase B
+ATGACGGACAAATTGaCCTCcCTTCGTCAGTACACCACCGTAgTGGCCGACACTGGGGACATCGCGGCAATGAAGcTGTaTCAACcGCAGGATGCCACAACCAAcCCTtCTCTCATTCTTAACGCAGCGCAGATTCcGGAATACCGTAAgTTgATTGaTGATGCTGTCGCCTGGGcGAaACaGCAGAGCAAcGATcGCgCgCAGCAgATCGtGGACGCGACCGAcAAACTGGCAGTAaATATTgGTCTgGAAaTCCTGAAACTGgTTCCGgGCCgTATCTCAActGAAGTtGATGCGCGTCTTTCCTATGACaCCGAAGCGTCAATTGCGAAAGCAAAACGCCTGATCAAACTCTACAACGATGcAGGTaTTAGCAACGATCgTaTTCTGATCAAACTGGCTTCTACCTGGCAGGGTATCCGTGCTGcAGAACAGCTGGAAAAAGAaGGTATTAACTGTAAcCTGACCCTGCTgtTCTCctTCGCtCAGGcTCGTGCTTGTGCGGaAGCGGgCGTgTTCCTGaTCTCGcCGTTTgTTGGCcGTATTCTTGACTGGTAcAAaGCGAATACCGaTAAGAAAGAGtACGCTCcGGCAGAAGATcCGGGCGTGGTTTCTGTatCtGAAATCtACCAGtACTACaAAGAGCATGGTTaTgAAACCGTGGTTATGGGCGCAAGCTTCCGTAACATCGGCGAAATTCTGGAAcTGGCAGGCTGCGACCGTCTGACCatCGCACCGgcACTGCTGAAAGAGCTGgCGGAGAGCGAAGGGGCTATCgAACGTAAACTgTCTTACAcTGgTGAAGTgAAAGCgCGTCCGGcGCGTATCACtGAGtCCGAGTTCCTgTGgCAgCACAACCAGGATCCAATGGCAGTaGATAAACTgGcGGaAGgTATCCGTAAGTTTGCTGTTGACCAGGAAAAACTGGAAAAAATGATCGGCGATCTGCtGTAA
+molybdopterin biosynthesis mog protein
+ATGAATACTTTACGTATTGGCTTaGTtTcCaTCTCTGATCGCGCATCCAGCGGCGTTTAtCAGgaTAAAgGCATCCCTGCGCTGGAagAATGGCTGACAtcGGCGCTAACCACGcCGTTTGAaCTGGAAAcCCgCTTaATCCCCGATGAGCAGGCGATCATCGAGCAaACgTTgTGTGAGCTGGTGGATGAAaTGAGtTGCCaTCTGGTGCTCACCACGGGCGGAAcTGGCCCTGCGCGTCGTGAcgTAACGCcCGATGcGACGCTGGCAGTAGCGGACCGCGAGATgCcAGGCTTTGGTGAACAGATGCGCCAGATCAGCCTGCATTTTGTACcaaCTGCGATCCTTTCGCGTCAGGTggGGGTgATTCGCAAACAGGCGCTGATCCTTAACTTaCcCGGTCAACCGAAGtCTATTAAAGAGACGCtGgAAGGTGtGAAGGACGCTGAGgGTAAcGTTGTGGTGCACGgTATTTTTGCCaGCGTaCcGTaCTGCATTCAGTTGCTGGAAGGGCCATACGTTGAaACGGCaCCgGaAGTGGTTGCAGCATTCAGaCCGAAGAGTGCAaGACGCGAAGtTAGCGAATAA
+chaperone protein DnaK
+aTGGGTAAAATAaTTGGTATCGACcTGGGTACtACCAaCTCTTGTGTagCGaTTAtGGATGGCACCACTCCtCGTGtACTGgAGAACGcCGAAGGCGATCGCACCAcGcCTTcTATCATTgCCTATACCCAGGAtGGTGAAACTCTGGTTgGTCAGCCGGCTAAACGTCAGGCAgtGACGAACCCgCAaAACAcCCTGTtTGCGATTAAACGCCtGATTGGCCGCCgCTTCCAGgACgAAGAAGTACAGCGtGATgTTTcCATCATGCCGTTCAAAATTAtTGcTGCtgatAACGGCGACGcATGGGTCGAAGtTAAAgGCCAGAAAATGGCAcCGCCGcAGAtCTCTGCTGAAGTGCTGAAAAAAAtGAAGAAAACCGCTGAAGaTTAcCTGGgTGAAcCGGTAACTGaAGCTgtTATTACCGTACCGGCAtACTttaACGATGCTCAGCGTCAGGcAACCAAAGaCGCAGGCCGTATCGCTGGTCTGGAAGTAAAaCGTATCATCAACGAaCCGACCGCAGCTGCGCTGGCTtACGGtCTGGACAAAGgTACTGGCAACCgtACTATCGCGGTTTATGACCTGGGTGGTGGTACTTTCGATATTTcCATTATCGAaATCGACGAAGTTGACGGCgAAAAAACCttCGAAGTTCTGGCAACCAACGGTGATACCCACCTGgGTGGtgAAGACTTCGACAGTCGTCTGATCAACTAtCTGGTTGAaGAATTCAAgAAAGATCAGGGCATTGacCtGCGCAACGaTcCGCTGGCAATGCAGCGCCTGAAaGAAGCGGCAGAAAAAGCgAAAATCGAACTGTctTCCGCTCAGcAGACCGaCGTTAACcTGCCGTACATCACTGCAGACGCGAcCGGTCCGAAACACAtGAACATCaAAgTGactCGTGCGAAACTGGAAAGCCTgGtTGAAGAtCTGGTAAACCGtTcCATTGAGCCGCTGAAAGTTGCACTGCAGGACGCTGGCCTGTCCGTATCTGATAtCGACgaCGTTATTCTCGTTGGTGGTCAGACTCGTATGCcAATGGtTCAGAAGAAAGTTGCTGaATTCTTTGGTAAAgAGCcGCGTAAAGATGTTAACCCGGACGAAGCTGTaGCCATCGgTGCTGCTGTTCAGGGTGGTGTTCTGACTGGtGAcGTAAAAGaCGTacTGCTgCtGGACGTTACCCCGCTGTCtCTGGGTATcGaAACCaTGGGCGGTGTGATGACCACGCTGATCGCgAaAAACACCACTATCCCGACCAaGcAcaGCCAGGTGTTCTCTACCGCTGAAGACAACCAGTCTGCGGTAACCATcCATgtGCTGcAGGGTGAACgTAaACGTGCgGCTGAtAAcaAATCTCTgggTCAGTTcAACCTGGATGGTATCAaCCCGGCACCGcGCGGCAtgCCGcAGATCGAAGtTACCtTCGAtATCGaTGCTGACGGTATCCTGCaCGTTTCCGCGAAAGACAAAAACAGCGGTAAAGAGCAGAAGATCAcTATCAaGGCTTCTTCTGGtCTGAaCGAAGAtGAAATCCAGAAAATGGTACGCGaCGCAGAAGCTAAcGCCGAAGCTGACCGTAaGTTTGAAGAGCTGGTACAGACtcGCaACCAGGGCGACCATCTGCTGCACAgCACCCGTAAGCAgGTTGAAGAAGCAGGCGACAaACTGCCGGCTGACGACAAAACTGCTATCGAGTCTGCGCTGActGCACTgGAAACtGCTCTGAAaGGTGAAGaCAAAGcCgCTATcGAAGCGAAAATGCAGGAACTGGCACAGGTTTCCCAGAAACTGATGGAAATCGCCCaGCAGCAACATGCcCAGCAGCAGACTGCCGGTGCTgATgCTTCtGCAAaCAAcGCGAAAGaTGACGATGTTGTCGACGCtGAATTTGAAGAAGTCAAAGACAAAAAATAA
+chaperone protein DnaJ
+GTGCatTCatCTAGGGGcAATTTAAAAAAGATGGCTAAGCAAGATTaTTACGAGaTTTTAGGCGTTTCCAAAaCAGCGGAAGAGCGtGAaaTCAAAAaGGCCTACAAACGCCTGGCCATGAAaTACCaCCCGGaCcGTAACCAGGgTGACAAAGaGGCCGAGGCGAAATTTAAAGAGATCAAGGaAGCTTATGAAGTTCTGACCGACtCGCAAAAACgTGCgGCATaCGATCAGTaTGGTCATGCTGCGTTTGAGCAAGGTGGCATGGGCGGCGGcGGtTTTGGCGGCGGCgCAGACTTcAGCGATAtTTtTGGTGACGtTTTCGGCgATATTTTTGGcGGCGGACGTGGTCGTCAACGTGCGGCGCGCGGTGCTGATTTAcGCTATAACATGGAGctCACcCtCGAAgAAGCTGTACGtgGCGtGaCCAAAGaGATccGCATtCCGACTCtGGAAGAGTGTGACGTTTGCCACgGTAGCgGTGCAAAACCaGGTACACAgCCgCAGACCTGTCCGACcTgTcATGGTTCTGGCCAGGtGCAGATGcGCCAGGGTTTCTTTGcCGTGCAGCAGACCTgTCcAcACTGTCAGGGCCGCGGTACGCTGaTcAAAGATCCGTGCAACAAATGTCATGGTCATGGTCGTGtTGAGCgCaGCAAAACGCTGTCCGTTAAAATCCCGGCaGGGgTGGACACTGGAGaCCGCATCCGTCTTGCGgGCGAAGGTGAAGCGGGTGAACACGgCGCACCGGCAGGCGATCTgTACGTTCAGGTtCAGGTtAAACaGCACCCGATTTTCGAGCGTGAAGGCAACAACCTGTATTGcGAAGTcCCGATCAAcTTCGCTATGgCGGCGcTGGGTGGTgaAATCGAAGTACcGACCcTTGATGGTcGcGTCaaACTGAAAGTGCCTGGCGAAACCCAGACCGGTAAgCTGtTCCgTaTGCGCGGTAAAGGCGTCAAGTCtGTcCGCGGTGGcgCACAGGGTGATTtGCTATGCCGCGTTGTTGTCgaAACAcCGGTAGGTTTGAACgAGAAGCAGAAACAGCTGCTGCAAGaGctGCAAGAAAGCtTTGGTGGcCCAACCGGCGAGCACAACAGCCCGCGTTCAAAGAGCtTCTTtGATGGCGTGAaGAAGTTTTTTGACGaCCTgACTCGCTAA
+hypothetical protein
+TTGCTCTTaCTCGGATTCgTAAGCCGTGAAAACAGCAaCCTCCGtCTGGCCAGTTCGGATGTGAACCTCACAGAGgTCTTTTCTCGTTACCAgCGCCGCCACTACGGCGGTgATACAGATGACGATCAGgGcgACaAtcAtCgCcTTATGCTGCTTCATTGCTCtCTtCTCCTTGACCTTTCGGTCaGTAAGAgGCACTCTACATGTGTTCTGCATATAGgGGGCCTCGgGTtGATGgTAAAATAtCACTCGGGGCTTTTCTCTAtCTGCCGTTCAGCTAATgCcTGA
+hypothetical protein
+aTGTCTGCCAAaaGACGACTTCTTATTGCGtGTACCTTGAtAaCAGCTATcTATCAtTTTCCTGcaTATTCTTCATTAgAATATAAAGGAtCCTTTGGTTCAATaAATGCGGGTTAtGCAGACTGGAATAGTGGaTTTgTAAaCACTCACCGTGGTGAaGTATGGAAAGTGACtGCGGATTTTGGGgTaAATTTTAAAGAAGCAGAATTTTACTCAtTTTATgAaAGTAATGTACTCAATCATGCTGTAGCAGGGAGAAATCATACgGtTTCAGCAATGaCGCATGTCAGACTCtTTGaCtCTGATaTGACATTCTTTGGCAAAATTTaTGgCCAATGGGATAACTCATgGggTGAcGATCTgGACATGTTTTATGGATTCGGTTACCTCGGCTGGAACGGCgAgTGGgGCTTTTtTAAACCGTATATTGGATtGCATAATCAATCTGGTGACTACGTATCAGCTAAATaTgGTCAAACGAATgGTTgGAATGGtTATGTTGTTGGCTGGACAGCAgTATTAcCATTTAcGTTATTTGACGAAAAATTTGTTTTATCTAACTGGAATGaAATAGAACTGGACAGGaACGATGCTTACACGgAgCAGcAATTTGGCcGGAACGGgTTaAaTGGCGGtTTAACTATTGcCTGGAAGTTCTATCCTCGCTGGAAAGCCAGtGTGACGTGGCGTTATTTcGATAAtAaGCTGGGCTACGATGGCTTTgGcgaTCAAATGATTTAtATGCTTGgTTATGATTTCtAA
+putative secreted sulfatase
+ATGCAGAAAACGTTAATGGCCAGTTTGATCGGCCTTGCAGTTTGCACAGGGAAtGCTTTTAGtCCTGCCTTAGCCGCAGAGGCTaAACAACcTAATTTAGTCATtaTTATGGCGGaTGATtTAGGTtaTGGCGAtTTAGcAaCaTATGGTCATCAGATCGTTAAAACACctAATATCGACAGGCtTGCCCAgGAAGGGGTCaAATTtACTGAcTaCTATGCCCCCGCTCCTTtAaGTTCAccTtCACGCGCaGGGCTATTAACCGGCcGGATGCCATTtCGTAcTGGAATTCGCTCATGGATtCCttCAGGCAAAGATGTTGCCtTAGGGCGTAACGAAcTCACgATTGCTAaTCTACTCAaAgCGCAaGGGTACGACACggCAATGATGGGTAAGCTGCATCTGAATgCAGGcGGCGaTCGCACCGATCAgCCaCAAGCACaAgATATGGGcTTTGATTAcTCAcTGGTtAATACgGCGGGCTTTGTTACcGACGCCACGCTGGATAAcGCTAAAGAACGCCcGCGTTATGGCATGGTTtAccCGACAGGCtgGCtACGTAACGGGCAACCCACTcCACGaGCTGATAAAAtGAGCGGTGAGTATGTCaGTTCGGAAGTCGTCAACTGGCTGGATAACAAAaaGGACaGCAAGCCTTTCTTCCTCTATgTTGCTTTTACCGAAGTGCATAGCCCCCTGGCTTCGCCCAAAaaATACCTCGATaTGTaCTCACaATATATGAGCGCGTATCAGAAGCAGcATCCTGATTTAtTTTaTGGCGACTGGGcAgACAAACCCTgGCGTgGTGTGGGgGAATATTAtGCCAATATCAGCTATCtGGATGCAcAGGTTGGAAAAgTGCTGGaTAAAATCAAAGCTGTGGgtGaAGaaGaTAACACAATCGTTATTTTTACCAGTGatAACGGTCCgGTAaCGCGTGAAGCGCGCAAAGTGTATgAGCTGAATTTGGCAGGGGAaACGGaTGGATTACGCGGTCGCAAGGATAACCTTTGGGAAGGCGGAATTCGtGTTCCaGCCATTATTAAATaTGGTAAACATCTACCACAGGGAATGGTTTCAGATACACCCGTTTATGGtCTgGACTGGATGCCTACtTTaGCgAaAATGATGAACTTCAAATTACCTACAGAcCGTAcTTTCGATGgTGAATCGCTGGTTCCTGtTcTTGAGCaAAAAGCATTGAAACGCGAAAAGCCATTAATTTTCGGGATTGATATGCCATTCCAGGATgATCCAAcCGATGAATGGGCGATCCGTGATGgTGACTGGAAgAtGATTATCGATCGcaATAATAAACcGAAATATCTCTACAATCTGAAATCTGATCGTTATGAAaCaCTTaAtCTGATCGGTAAAAAAACAgATATTGAAAAACAGATGTATGGTaAGtTTtTAAAATATAAAACTGATATTGATaATGATtCTCTAATGAAAgCCAGAGGTGATAAACCAGAAGCGGTGACCTggGGCTAa
+putative cytoplasmic protein
+ATGTTTACcAacGTAAATGTTGATTGtTgCAAAACACCAGGAtGTAAaaACCTGGGGTTGCTGAATAGCCAGGATTATGTCGCAcAGgGTaAaAATATTTtATGCCGTGAATGTgGTTaCTTGTtTCCAGtGATATCTGAACAGTCGCTTAAtATTTaTCGTAATATTGTGAAtcACTcCTGGAGAGGTTTGATTTGCCAATGTTCAACTtGCGGAGGcACGTCCCTCAAAAAATaTGgATATtCtGCAcAagGCCAgAGAAGAATgTATTGCcaTCAtTGTGaGAAAACaTTtATCACTCTGGAAcAtGTAATTACcACACCACGAGGAGCcCTGTTAGcATTGATGATTGAGCAAGGGGAGGCACTTGCGGaTATCAgAAAGTCATTACGTCTTAACAgCACTGGACTTAGCCGTGAACTGTTAAAATTAGCGCGTGAAGcAAACTATAAAGAAAGTCGACAGTGTTTCCCTGCTTCTGATATTACCCTGAGtACCCGCGCTTtTCGcgTCAAGTAtAATGGTAGCAATAACTCTCTTTATGCTCTTGTTACCGCAGAAGAACAAAGcGGCAGGGTgGTTGcCaTCTCAACCAATTACTCCCCATCtGCCGTAGagCaaCATTATcAATACaCATCGAACtATGAAGAGcGTATGTCTCCAGGGACGCTGGCACAtCATGTCCAGCGCAAAGAGttACTTACTATGCGGCgGGATACCTTGTTTGATATTGATTACGGCcCGgCAGTTTTACATCAAAACGATCCGGGAATGtTGGTAaAaCCGGTTCTTCCGGCATaTCGTCATTTTgAACTGGTCAGAATACTGACCGATGAGCATtCCAACAACGTTCAGCATTACCTTGATCACGAATGCTTTATaTTGGGCGGCTGcCTGATGGCTAATTTGCAGCaTATTCATCAaGGTCGCTGCCATATTTCcTTTGTCAAaGAGCGcGGTGTGGCACCCGCCACCATTGaTTTTCCACCGCGATtATTCcTTAGTgGtGGgGTACgAAATAATGTCTGGCGTGCaTTTTCTAACCGCAATTATTCAaTGGCTGTATGCAAtCTCaCTGGCAGTAAGAAAGTCCGCGAGATGCGGCATGCAACATtGAACAGTGCGACGCgTTtTATCCACTTTGTGgaGAACCATCCTTTCCTTATaTCATTGAACCGAATgtCTCCTGCGaaTGTCgtTTCTACaTTAGATaTCCTCAAACaTCTGTGGAATAaAaAACTAGagCATGGAACAATTtAA
+sodium/proton antiporter 1
+GTGAAACATCTGcATCGATTCTTTAGCaGTGATGCCTCGGGAGgCATTATTCTCATTATTGCCGCTGTATTAGCGATGATTATGGCCAACAGCGGTgcAaCCAGTGGATGGTATCACGACTTTCTTGAGACGCcGGTTCAGcTcCGGGTTGGGACACTTGAGATCAACAAGAACATGCTGCTATGGATCAATGaCGCTCTGaTgGCGGTATTTTTCCTGTtGGTTGGTcTGGaAGTTAAAcGCGAGcTGaTGCAaGGTTCGCTGGCCAGTCtGCgCCAGGCGGCatTTCCTGTTATTGCCGcAATCGGCGGGATGATTGTCCCGGCATTGCTCTATCTGGCTtTtAACTATGCCGATCCGaTTaCCCGCGAAGGcTGGGCAatCCCGGCGGCGACTGacATTGCCTTTGCACTTggTgTGTTGGCGCTgTTGGGAAGTCGTGTTCCGTTAGCGCtGAAGATCTTTTtGATGGCTCTGGCtATTATCGACGATCTTgGGGcCATCATtATCATCGCATTGTTCTACAcTAATGACTTATCGATGGCCTcTCTTGGCGTcGCgGCTGTAGCAATTGCGgtACTCGCGGTATTGAAtCTGTgTGGTGTAcGCCGCACGGGCGTtTATATTCTGGTTGGCGTGGTGCtGTGGaCAGCGGTGTTGAAATCGGGGGTTCACGCAACCcTGGCTGGCGtCATtGtCGGCTTCTTTATTCCTTTGAAAGAGAAGCATGGgCGCTCTCcGgCTAAACGTCTGGAGCATGTTTTGCAtCCATGGGTGGCGTATCTGATtTTGCCGCTGTTTGCATTTGCTAATGCTGGCGTTTCACTGCAaGGTgTCACGCtggAaGGTTTgACCtCCATTCTGCCATTAGgGATCATCGCTGGTTTGCTGaTTGGCaAGCCACtGGGTAtTaGTCTgttcTGCTGGtTGGcgCTGCGTTTGAAATTGGCACATCTGCCAGAGGGAACgACTtACCAGCAAATTATGGCGGtTGGTaTCcTGTGCGgTATCgGTTtTAcTatGTCTATCTTTATTGCCAGCCTGGcATTTGGTAgCGTAGATcCAGAaCTGaTTAACtGGGCAAAAtTAgGTATCCTTGTCGGTTCAATTTCtTcGgCGGTAATTGGATATAGcTGGTTACGcGTTCGTTTACGTCcATcAGTTTGA
+transcriptional activator protein NhaR
+ATGAGCATGTCTCATaTCAATTACAACCACTtGTATTACTTCTGGCaTGTCTAcAAAgAaGGTTCTGtGGTTGGCgCAGCGGAGGCGCTTTATTTAACAcCAcAAACCATTACCGGGCaGATCCGGGCGCTGGAaGAGCGCCTGCAAGGGAAAcTATTTAAGCGTAAAGGAcgTGGTCTGGAACCCAgcGAACTGGGGGAACTGGTCTATCGCtATGCCGATAAAATGTTCAcCTTAAgCCAGGAAATGCTgGATATCGTCAACTATCGCAAAGAGTCCAACTtATTGtTTGATGTTgGTGTGGCAGATGCACTTtcCAAAcGtcTGGTCAGCAGTGTTCtgGATgCCGCAGTtgTGGAAGACGAGCAGAtCCATCTACGCTGTTTCGAaTCGACGCACGAGATgCTTTTaGAGCAgtTGAGTCAGCATAaACTGGATATGATcaTCTCTGACTGTCCGaTCGATTCCACTCAGCAGGAAGGGCTGTTTTCCATGAAAaTtGGCGAATGTGGTGTCAgtTTCTGGTgCACTAACCCACTACcAGAAAAGCCGTTTCCTGCCtGTCTTGAAgAGCgTCGtTtACTTATTCCGGGGCGTCGCTCAaTgTTGGGGCGtAAACTATTAAACTGGTTTAACTCcCAGGGCTTGAACGTCGAAATTTTGgGTGAGTTTGATGATGCTGCGTTGATGAAAgCCTTTGGGGCGAcGCATAACGcTATTTTCGTTGCACCTTCGCtTTACGCTAATgATTTCTATAACgATGACTCGgTtGTGgAGATAGgCCGTGTTGAGaACGTGATGGAAGAGTACCACGCGATTTtTGCCGaAAGgaTGAtTCAgCACCCTGcAGTAcAGCGTATCTGcAATACAgacTATTCTGCGCtgTTTACTCCAGCTTcAAAATAA
+riboflavin kinase
+ATGAAGCTGATACGCGgCAtACATAATCTCAGCCAGGCCCCGCAAGAAGGGTGTGTGCTGACTATTGGTaATTTCGACGGCGTGCATCGCggTCATCGCGCGCTGTTACAGGGCtTGCAGGAAGAAGGGCGCAAGCGCAACtTACCGGTGATGGTGATGCTTTTtGaACCTCAACCAcTGGAACTGTTTGCTACTGAtAAAGCcCCGGCACGGcTcACcCGGCTGCgGGAAAAACTGCgTtaTcTTgCAGAgTGTGGCGTTGATTACGTGCTGTGCGtGCGTtTTGaCaGGCGTtTTGCGGCGTTAACCGCGcAAAACTTCATCAgTGATCTtCTGGTGAAGCACTTGCGGGTAAAATTTCTTGCCGTAGGTGACGAtTTCCGCTTTggCGCTGgTCGTGAAgGCGAtTTCTtGTTATTACAGAaAGcgGGCATGGAATACGGCTTCGATATcACCAGCaCGCAAAcTTtTTGCGAAGGTGGTGTGCGtATCAGcAGCACCGCCGtgCGTCAGGCGCtTGCGgATgACAATCTGGCTCTGGCAGAAAGTTTACTGGgGCACCCGTTTGCTATCTCCGGGCGTGTAGTCCACGGTGATGaATTAGGGCGCAcTATAGGTTTCCCgACGGCGaATGTACCGcTaCgCCGTCAGGTTTCCCCGGTGAAAgGGGTTTATGCGGTAGaAgTgTTGGgCCtTGgCGAAaAGcCGTTAcCCGGcgTTGCAAACaTCGGAACACgCCCAACGGTTGCcGGTATTCGCCAGCAACTGgaAGTGCATTTGTTAGATGTTGcAATGGaCCTTTATGGTCGCCAtATACAAGTAGTGCTGCGtAAAAaAATAcGCAATGAGCAgCGATTTGcATCGCTGGACGAACTGAAAGCGCAGATTGCGCGTGATGAATTAACCGcCCGCGaaTTTtTTGGGCTAAcAAAACCGGCTTAa
+Isoleucyl-tRNA synthetase
+ATGAGTGACTATAAATCaACCCTgAATTTGCCgGAAACAGgGTtCCCGATgCGTGGCGATCTCGcCAAGCGCGAAcCGGGaATGCTGGCGCGTTGGACTGATGATGATCTgTaCGGCATCATCCGTGCGGCTaAAAAAGGCAaAaAAACCTTCAtTCTGCATgATGGCCcTCCTTATGCGAATGGCAGCAtTCaTATTGGTcACTCGGTTAACAAGATTCTGAAAGACATTaTCATTaAgTCCAAAgGGCTttCTGGATATGACTCGCCGTATGTGCCTGGCTGGGACTGTCaTGGtCTGCCAATCGAAcTGAAAGTAGAGCAAGAATACGGTAAGCCGGGgGAGaAaTTCACCGCCGcTGAGTtCCGCGCCAAGTGCCGCGAATACGCTGCgACCCAGGTTGACGGTCAGCGCAAAGACTTTaTCcGTCTGGGCGTGCTGGGCGActgGTCgcACCCGTACCTGACCATGGACtTCAAAACTGAAGCCAACATCATCCgCGCGCTGGGCAAAATCATCGGCAAcGGTCACCTGCACaAAGGcGCGAAGCCGGTgCACTGGTGCgTTGACTGCCGTTCTgCACTGGCAGAAGCGGAAGtTgAGTATTACGacAAAACTtCTCCGTCCATCGACGTCGCTTtCCAGGCGGTCGATCaGGATGCGCTGAAAACGAAATTTGGCGTAAGCAATgTTAACGGCCCAATTTCGCtGGTTATCTGGaCcACCACGcCGTGgAcGCTGCcTGCTAacCGCgCAATCTCcATtGCACCTGATTTTGAttATGCGCTGGTGCaAatCgACGGTCAGgCCGTGATCCTCGCGAAAGATCtGGtTGaAAGCGTAAtGCAGCGTATCGGCGTTAGCGaTTACACCATTCTTGGCAcGGtgAAAGGTGCCGAGCtGGAACTGTTgCGCTTTACCCATCCGTTtATGGACtTCGATGTTCCGGCAaTTCTCGGCGACcACGTTACgCTGGATGCCGGTACCGGTGcCGTTCATACCGCGCCAGGCcACGGTCCGGaCGACTATgTGATCGGTcAAAAATaTGgTCTGGAAaCCGCTAACCCgGTTgGCcCGGACGgCACtTaTCTGCcGgGTACTTACCCGACTCtGGATgGCGTTaACGTCTTCAAAGCGAACGaTATTGTCATTGCGTTGTTgCAGGAAAAAGGcgCACTGTTGCACGTTGAGAAAATGCAACACAGCTATCCGTgCTGCtGGCGTCaTAAaACGCCGATCAtCTTCCGcgCGACGCCGCAGTGGTTCGTCAgCAtgGATCAGAAAGGTCTGCgTGCGcAGTCACTGAAAGAGATCAAAGGCgTGCAGTGGATCCCTGACTGGGGCCAGGCGCGTATCGAGTCGATGGTTGCTAACCGTCCTGACTGGTGTATcTCTCGTCaGCGTACCTGGGGcGTGCCgATGTCACTGTTCGTgCaCAaaGACACAGAAGAaCTGcATCCGCgTACTCtcGAACTGaTGGAAGAAGTGGcAAAACGCGTTgAAGTtGACgGCATTCAGGCgTGGTGGGATCTCGATGCGAAaGAgATCcTCGGCGaCGAAGCTGACCAGTATGTGAAAGTACCGGATACGCtGgATGTATGGTtTGACTCCGGATCTACCCACTCTTCCGTTGTTGATGTGCGTcCGGAATtTGCCGGTCACGCAGCGGACATGTaTcTGgAaGGTTCTGACCAACACcGTGgCTGGTtCATGTCtTCCCTGATGATCTCTACCGCGATGAAGGGcAAAGcGCCATATCGTCAGGTACTGACTCACGGCTTTAcCGTGGATGGTCAGGGTCGCAAGATGTCTAAATCCATCGGtAACaCcGTTTCGCCGCAGGATGTgATGAATAAACtGGGtGCGGATATTCTGCGTCTGTGGGTGGcATCAACCGACTAcACTGGCGAAATGGCcGtTTCTGACGAGATCcTGAAACGtGCTGCcGACAGCTATCGTCGTATCcGTAACAcCgCGCGCTTCCTGCTGGCAAACCTGAACgGTTtTGAtCCGGCaAAAGaTATGGTGAAACCGGAAGAGATGGTGGTaCTGGATCGCTGGGCCGtAGGTTGTGCGAAAGCGGCACAGGAAGACATCCtCAAGGCgTACGAAGCATACGATTTCcACGAAGTGGTaCAGCGTcTGaTGCGCtTCTGCTCCGTTGAGATGgGTTccTTCTACCTCGACATCATCAAAGACCGTCAgTATACcGCCAAAGCGGaCAGCGTGGCGCGTCGTAGCTGCCAGAcTgCGCTGTATCACATCGCaGAAGCGCTGGTTCGCTGGATGGCAcCAATCCTCTCCTTCaCcGCTGaTGAAGTGTGGGGtTaCCTGCCggGCGAACGTGAAAAATACGTCTTCAcCGGCgAgTGgTACGAAGGCCTGtTTGGTCTGGCAGACAGTGAAGCAATGAACGaTGCGTTCTGGGACGAGCTGTTGAAAGTGcGTGGCGAAGTGAAcAAAGTcaTTGAGCAAGCgCGTGCCGATAAGAACGTGGGcGGCTCGCTGGAAGCGGCAGTAAcCTTGTATGCAGAACCGGAaCTGGCgGCGAaaCTGaCCGcGCTGGGCGAtGAATTACGATTTGTCCTGtTGACCTCCGgCGCTAcCGTTGcAGACtATAACGACGCACCTGCTGATGCCCAGCAGaGCGAaGTcCTCAAAGGGCTGAAAgtCGCGTTGAGTAAAGCCgAAGGtGaGAAGTGTCCtcGctGCTGgCACTACACCcAGgATGTcGgCAAGGTGGCGGaACACGCAGAAATCTGCGGCCGCTGTgTcAgCaACGTCGCCGGTGACGGTGAAAAaCGTAAGTTTGCCTGA
+Non-protein region
+GCTTGCGCCAACGcCATTTCATCGCCATCCCGCCgAgcATACAGGCCTCGgAaGAACCAaTGGTGTTGGTGcCAACGGCCtGAccATTTTTcGGTGCAGGCGCATGCCACAGATCGGCAACCATGTTTACGCAACGCAGATCGATTGCTGcAGaTTGCGGATATTctTCTTTGTCGATCCAGTTTTTGTtAATGGAtAAAtCCA
+FKBP-type 16 kDa peptidyl-prolyl cis-trans isomerase
+ATGTCTGAATCTGTACAGaGCAaTAgCGCCGTCCTGGTGCACTTCACGCTAAAACTCGACGAtGGCaCCAcCGCTGAGTCTACCCGCAaCAaCGGTAaACCGGCGCTGTTCCGCcTGgGTgATGCTTCTCTTTCTgAaGgGCTGGAGCAACACCTGCTgGGGCTGAAAGTGGgCGATAAAACCaCCTTCtCGCTGGAGCCAGATGCGGCgTTtgGCGTGCCGTcACCgGAcCTGATtCAGTAcTTCTCcCGCCGTGAATTTATGgATGCAGGCGAGCcaGAAATTGGCGCAATCATgCTTTTTACCGCAATGGaTGGCAGTGAGATGCCTGGCGTGaTCCGCgAAATTAACGGCGACTCCATTACCGTTGATTTCAACCaTCCGCTgGCCGGGCAGACCGTTCATTTTGATATTGaagTGCTGGaAATCGATCCGGCAcTGGAGGcGTaA

src/main/java/com/matthewjensen/project/modules/dna/spec/ecoli_console.txt

@@ -0,0 +1,5 @@
+This program reports information about DNA
+nucleotide sequences that may encode proteins.
+
+Input file name? ecoli.txt
+Output file name? ecoli_file.txt

src/main/java/com/matthewjensen/project/modules/dna/spec/ecoli_file.txt

@@ -0,0 +1,140 @@
+Region Name: thr operon leader peptide
+Nucleotides: ATGAAACGCATTAGCACCACCATTACCACCACCATCACCATTACCACAGGTAACGGTGCGGGCTGA
+Nuc. Counts: [21, 22, 12, 11]
+Total Mass%: [33.5, 28.9, 21.4, 16.2] of 8471.7
+Codons List: [ATG, AAA, CGC, ATT, AGC, ACC, ACC, ATT, ACC, ACC, ACC, ATC, ACC, ATT, ACC, ACA, GGT, AAC, GGT, GCG, GGC, TGA]
+Is Protein?: YES
+
+Region Name: aspartokinase I/homoserine dehydrogenase I
+Nucleotides: ATGCGAGTGTTGAAGTTCGGCGGTACATCAGTGGCAAATGCAGAACGTTTTCTGCGGGTTGCCGATATTCTGGAAAGCAATGCCAGGCAGGGGCAGGTGGCCACCGTCCTCTCTGCCCCCGCCAAAATCACCAACCATCTGGTAGCGATGATTGAAAAAACCATTAGCGGTCAGGATGCTTTACCCAATATCAGCGATGCCGAACGTATTTTTGCCGAACTTCTGACGGGACTCGCCGCCGCCCAGCCGGGATTTCCGCTGGCACAATTGAAAACTTTCGTCGACCAGGAATTTGCCCAAATAAAACATGTCCTGCATGGCATCAGTTTGTTGGGGCAGTGCCCGGATAGCATCAACGCTGCGCTGATTTGCCGTGGCGAGAAAATGTCGATCGCCATTATGGCCGGCGTGTTAGAAGCGCGTGGTCACAACGTTACCGTTATCGATCCGGTCGAAAAACTGCTGGCAGTGGGTCATTACCTCGAATCTACCGTTGATATTGCTGAATCCACCCGCCGTATTGCGGCAAGCCGCATTCCGGCTGACCACATGGTGCTGATGGCTGGTTTCACTGCCGGTAATGAAAAAGGCGAGCTGGTGGTTCTGGGACGCAACGGTTCCGACTACTCCGCTGCGGTGCTGGCGGCCTGTTTACGCGCCGATTGTTGCGAGATCTGGACGGATGTTGACGGTGTTTATACCTGCGATCCGCGTCAGGTGCCCGATGCGAGGTTGTTGAAGTCGATGTCCTATCAGGAAGCGATGGAGCTTTCTTACTTCGGCGCTAAAGTTCTTCACCCCCGCACCATTACCCCCATCGCCCAGTTCCAGATCCCTTGCCTGATTAAAAATACCGGAAATCCCCAAGCACCAGGTACGCTCATTGGTGCCAGCCGTGATGAAGACGAATTACCGGTCAAGGGCATTTCCAATCTGAATAACATGGCAATGTTCAGCGTTTCCGGCCCGGGGATGAAAGGGATGGTTGGCATGGCGGCGCGCGTCTTTGCAGCGATGTCACGCGCCCGTATTTCCGTGGTGCTGATTACGCAATCATCTTCCGAATACAGTATCAGTTTCTGCGTTCCGCAAAGCGACTGTGTGCGAGCTGAACGGGCAATGCAGGAAGAGTTCTACCTGGAACTGAAAGAAGGCTTACTGGAGCCGTTGGCGGTGACGGAACGGCTGGCCATTATCTCGGTGGTAGGTGATGGTATGCGCACCTTACGTGGGATCTCGGCGAAATTCTTTGCCGCGCTGGCCCGCGCCAATATCAACATTGTCGCCATTGCTCAGGGATCTTCTGAACGCTCAATCTCTGTCGTGGTCAATAACGATGATGCGACCACTGGCGTGCGCGTTACTCATCAGATGCTGTTCAATACCGATCAGGTTATCGAAGTGTTTGTGATTGGCGTCGGTGGCGTTGGCGGTGCGCTGCTGGAGCAACTGAAGCGTCAGCAAAGCTGGTTGAAGAATAAACATATCGACTTACGTGTCTGCGGTGTTGCTAACTCGAAGGCACTGCTCACCAATGTACATGGCCTTAATCTGGAAAACTGGCAGGAAGAACTGGCGCAAGCCAAAGAGCCGTTTAATCTCGGGCGCTTAATTCGCCTCGTGAAAGAATATCATCTGCTGAACCCGGTCATTGTTGACTGTACTTCCAGCCAGGCTGTGGCAGATCAATATGCCGACTTCCTGCGCGAAGGTTTCCACGTTGTTACGCCGAACAAAAAGGCCAACACCTCGTCGATGGATTACTACCATCAGTTGCGTTATGCGGCGGAAAAATCGCGGCGTAAATTCCTCTATGACACCAACGTTGGGGCTGGATTACCGGTTATTGAGAACCTGCAAAATCTGCTCAATGCTGGTGATGAATTGATGAAGTTCTCCGGCATTCTTTCAGGTTCGCTTTCTTATATCTTCGGCAAGTTAGACGAAGGCATGAGTTTCTCCGAGGCGACCACACTGGCGCGGGAAATGGGTTATACCGAACCGGACCCGCGAGATGATCTTTCTGGTATGGATGTGGCGCGTAAGCTATTGATTCTCGCTCGTGAAACGGGACGTGAACTGGAGCTGGCGGATATTGAAATTGAACCTGTGCTGCCCGCAGAGTTTAACGCCGAGGGTGATGTCGCCGCTTTTATGGCGAATCTGTCACAGCTCGACGATCTCTTTGCCGCGCGTGTGGCGAAGGCCCGTGATGAAGGAAAAGTTTTGCGCTATGTTGGCAATATTGATGAAGATGGCGTCTGCCGCGTGAAGATTGCCGAAGTGGATGGTAATGATCCGCTGTTCAAAGTGAAAAATGGCGAAAACGCCCTGGCCTTCTATAGCCACTATTATCAGCCGCTGCCGTTGGTACTGCGCGGATATGGTGCGGGCAATGACGTTACAGCTGCCGGTGTCTTTGCTGATCTGCTACGTACCCTCTCATGGAAGTTAGGAGTCTGA
+Nuc. Counts: [551, 608, 692, 612]
+Total Mass%: [23.0, 20.9, 32.4, 23.7] of 323152.2
+Codons List: [ATG, CGA, GTG, TTG, AAG, TTC, GGC, GGT, ACA, TCA, GTG, GCA, AAT, GCA, GAA, CGT, TTT, CTG, CGG, GTT, GCC, GAT, ATT, CTG, GAA, AGC, AAT, GCC, AGG, CAG, GGG, CAG, GTG, GCC, ACC, GTC, CTC, TCT, GCC, CCC, GCC, AAA, ATC, ACC, AAC, CAT, CTG, GTA, GCG, ATG, ATT, GAA, AAA, ACC, ATT, AGC, GGT, CAG, GAT, GCT, TTA, CCC, AAT, ATC, AGC, GAT, GCC, GAA, CGT, ATT, TTT, GCC, GAA, CTT, CTG, ACG, GGA, CTC, GCC, GCC, GCC, CAG, CCG, GGA, TTT, CCG, CTG, GCA, CAA, TTG, AAA, ACT, TTC, GTC, GAC, CAG, GAA, TTT, GCC, CAA, ATA, AAA, CAT, GTC, CTG, CAT, GGC, ATC, AGT, TTG, TTG, GGG, CAG, TGC, CCG, GAT, AGC, ATC, AAC, GCT, GCG, CTG, ATT, TGC, CGT, GGC, GAG, AAA, ATG, TCG, ATC, GCC, ATT, ATG, GCC, GGC, GTG, TTA, GAA, GCG, CGT, GGT, CAC, AAC, GTT, ACC, GTT, ATC, GAT, CCG, GTC, GAA, AAA, CTG, CTG, GCA, GTG, GGT, CAT, TAC, CTC, GAA, TCT, ACC, GTT, GAT, ATT, GCT, GAA, TCC, ACC, CGC, CGT, ATT, GCG, GCA, AGC, CGC, ATT, CCG, GCT, GAC, CAC, ATG, GTG, CTG, ATG, GCT, GGT, TTC, ACT, GCC, GGT, AAT, GAA, AAA, GGC, GAG, CTG, GTG, GTT, CTG, GGA, CGC, AAC, GGT, TCC, GAC, TAC, TCC, GCT, GCG, GTG, CTG, GCG, GCC, TGT, TTA, CGC, GCC, GAT, TGT, TGC, GAG, ATC, TGG, ACG, GAT, GTT, GAC, GGT, GTT, TAT, ACC, TGC, GAT, CCG, CGT, CAG, GTG, CCC, GAT, GCG, AGG, TTG, TTG, AAG, TCG, ATG, TCC, TAT, CAG, GAA, GCG, ATG, GAG, CTT, TCT, TAC, TTC, GGC, GCT, AAA, GTT, CTT, CAC, CCC, CGC, ACC, ATT, ACC, CCC, ATC, GCC, CAG, TTC, CAG, ATC, CCT, TGC, CTG, ATT, AAA, AAT, ACC, GGA, AAT, CCC, CAA, GCA, CCA, GGT, ACG, CTC, ATT, GGT, GCC, AGC, CGT, GAT, GAA, GAC, GAA, TTA, CCG, GTC, AAG, GGC, ATT, TCC, AAT, CTG, AAT, AAC, ATG, GCA, ATG, TTC, AGC, GTT, TCC, GGC, CCG, GGG, ATG, AAA, GGG, ATG, GTT, GGC, ATG, GCG, GCG, CGC, GTC, TTT, GCA, GCG, ATG, TCA, CGC, GCC, CGT, ATT, TCC, GTG, GTG, CTG, ATT, ACG, CAA, TCA, TCT, TCC, GAA, TAC, AGT, ATC, AGT, TTC, TGC, GTT, CCG, CAA, AGC, GAC, TGT, GTG, CGA, GCT, GAA, CGG, GCA, ATG, CAG, GAA, GAG, TTC, TAC, CTG, GAA, CTG, AAA, GAA, GGC, TTA, CTG, GAG, CCG, TTG, GCG, GTG, ACG, GAA, CGG, CTG, GCC, ATT, ATC, TCG, GTG, GTA, GGT, GAT, GGT, ATG, CGC, ACC, TTA, CGT, GGG, ATC, TCG, GCG, AAA, TTC, TTT, GCC, GCG, CTG, GCC, CGC, GCC, AAT, ATC, AAC, ATT, GTC, GCC, ATT, GCT, CAG, GGA, TCT, TCT, GAA, CGC, TCA, ATC, TCT, GTC, GTG, GTC, AAT, AAC, GAT, GAT, GCG, ACC, ACT, GGC, GTG, CGC, GTT, ACT, CAT, CAG, ATG, CTG, TTC, AAT, ACC, GAT, CAG, GTT, ATC, GAA, GTG, TTT, GTG, ATT, GGC, GTC, GGT, GGC, GTT, GGC, GGT, GCG, CTG, CTG, GAG, CAA, CTG, AAG, CGT, CAG, CAA, AGC, TGG, TTG, AAG, AAT, AAA, CAT, ATC, GAC, TTA, CGT, GTC, TGC, GGT, GTT, GCT, AAC, TCG, AAG, GCA, CTG, CTC, ACC, AAT, GTA, CAT, GGC, CTT, AAT, CTG, GAA, AAC, TGG, CAG, GAA, GAA, CTG, GCG, CAA, GCC, AAA, GAG, CCG, TTT, AAT, CTC, GGG, CGC, TTA, ATT, CGC, CTC, GTG, AAA, GAA, TAT, CAT, CTG, CTG, AAC, CCG, GTC, ATT, GTT, GAC, TGT, ACT, TCC, AGC, CAG, GCT, GTG, GCA, GAT, CAA, TAT, GCC, GAC, TTC, CTG, CGC, GAA, GGT, TTC, CAC, GTT, GTT, ACG, CCG, AAC, AAA, AAG, GCC, AAC, ACC, TCG, TCG, ATG, GAT, TAC, TAC, CAT, CAG, TTG, CGT, TAT, GCG, GCG, GAA, AAA, TCG, CGG, CGT, AAA, TTC, CTC, TAT, GAC, ACC, AAC, GTT, GGG, GCT, GGA, TTA, CCG, GTT, ATT, GAG, AAC, CTG, CAA, AAT, CTG, CTC, AAT, GCT, GGT, GAT, GAA, TTG, ATG, AAG, TTC, TCC, GGC, ATT, CTT, TCA, GGT, TCG, CTT, TCT, TAT, ATC, TTC, GGC, AAG, TTA, GAC, GAA, GGC, ATG, AGT, TTC, TCC, GAG, GCG, ACC, ACA, CTG, GCG, CGG, GAA, ATG, GGT, TAT, ACC, GAA, CCG, GAC, CCG, CGA, GAT, GAT, CTT, TCT, GGT, ATG, GAT, GTG, GCG, CGT, AAG, CTA, TTG, ATT, CTC, GCT, CGT, GAA, ACG, GGA, CGT, GAA, CTG, GAG, CTG, GCG, GAT, ATT, GAA, ATT, GAA, CCT, GTG, CTG, CCC, GCA, GAG, TTT, AAC, GCC, GAG, GGT, GAT, GTC, GCC, GCT, TTT, ATG, GCG, AAT, CTG, TCA, CAG, CTC, GAC, GAT, CTC, TTT, GCC, GCG, CGT, GTG, GCG, AAG, GCC, CGT, GAT, GAA, GGA, AAA, GTT, TTG, CGC, TAT, GTT, GGC, AAT, ATT, GAT, GAA, GAT, GGC, GTC, TGC, CGC, GTG, AAG, ATT, GCC, GAA, GTG, GAT, GGT, AAT, GAT, CCG, CTG, TTC, AAA, GTG, AAA, AAT, GGC, GAA, AAC, GCC, CTG, GCC, TTC, TAT, AGC, CAC, TAT, TAT, CAG, CCG, CTG, CCG, TTG, GTA, CTG, CGC, GGA, TAT, GGT, GCG, GGC, AAT, GAC, GTT, ACA, GCT, GCC, GGT, GTC, TTT, GCT, GAT, CTG, CTA, CGT, ACC, CTC, TCA, TGG, AAG, TTA, GGA, GTC, TGA]
+Is Protein?: YES
+
+Region Name: homoserine kinase
+Nucleotides: ATGGTTAAAGTTTATGCCCCGGCTTCCAGTGCCAATATGAGCGTCGGGTTTGATGTGCTCGGGGCGGCGGTGACACCTGTTGATGGTGCATTGCTCGGAGATGTAGTCACGGTTGAGGCGGCAGAGACATTCAGTCTCAACAACCTCGGACGCTTTGCCGATAAGCTGCCGTCAGAGCCACGGGAAAATATCGTTTATCAGTGCTGGGAGCGTTTTTGCCAGGAGCTTGGCAAGCAAATTCCAGTGGCGATGACTCTGGAAAAGAATATGCCGATCGGTTCGGGCTTAGGCTCCAGCGCCTGTTCAGTGGTCGCGGCGCTGATGGCGATGAATGAACACTGCGGCAAGCCGCTTAATGACACTCGTTTGCTGGCTTTGATGGGCGAGTTGGAAGGGCGTATCTCCGGCAGCATTCATTACGACAACGTGGCACCGTGTTTTCTTGGTGGTATGCAGTTGATGATCGAAGAAAACGACATCATCAGCCAGCAAGTGCCAGGGTTTGATGAGTGGCTGTGGGTGCTGGCGTATCCGGGGATTAAAGTCTCGACGGCAGAAGCCAGGGCTATTTTACCGGCGCAGTATCGCCGCCAGGATTGCATTGCGCACGGGCGACATCTGGCAGGCTTCATTCACGCCTGCTATTCCCGTCAGCTTGAGCTTGCCGCGAAGCTGATGAAAGATGTTATCGCTGAACCCTACCGTGAACGGTTACTGCCAGGCTTCCGGCAGGCGCGGCAGGCGGTTGCGGAAATCGGCGCGGTAGCGAGCGGTATCTCCGGCTCCGGCCCGACTTTGTTCGCTCTGTGTGACAAGCCGGATACCGCCCAGCGCGTTGCCGACTGGTTGGGTAAGAACTACCTGCAAAATCAGGAAGGTTTTGTTCATATTTGCCGGCTGGATACGGCGGGCGCACGAGTACTGGAAAACTAA
+Nuc. Counts: [193, 226, 295, 219]
+Total Mass%: [21.2, 20.4, 36.2, 22.2] of 123170.2
+Codons List: [ATG, GTT, AAA, GTT, TAT, GCC, CCG, GCT, TCC, AGT, GCC, AAT, ATG, AGC, GTC, GGG, TTT, GAT, GTG, CTC, GGG, GCG, GCG, GTG, ACA, CCT, GTT, GAT, GGT, GCA, TTG, CTC, GGA, GAT, GTA, GTC, ACG, GTT, GAG, GCG, GCA, GAG, ACA, TTC, AGT, CTC, AAC, AAC, CTC, GGA, CGC, TTT, GCC, GAT, AAG, CTG, CCG, TCA, GAG, CCA, CGG, GAA, AAT, ATC, GTT, TAT, CAG, TGC, TGG, GAG, CGT, TTT, TGC, CAG, GAG, CTT, GGC, AAG, CAA, ATT, CCA, GTG, GCG, ATG, ACT, CTG, GAA, AAG, AAT, ATG, CCG, ATC, GGT, TCG, GGC, TTA, GGC, TCC, AGC, GCC, TGT, TCA, GTG, GTC, GCG, GCG, CTG, ATG, GCG, ATG, AAT, GAA, CAC, TGC, GGC, AAG, CCG, CTT, AAT, GAC, ACT, CGT, TTG, CTG, GCT, TTG, ATG, GGC, GAG, TTG, GAA, GGG, CGT, ATC, TCC, GGC, AGC, ATT, CAT, TAC, GAC, AAC, GTG, GCA, CCG, TGT, TTT, CTT, GGT, GGT, ATG, CAG, TTG, ATG, ATC, GAA, GAA, AAC, GAC, ATC, ATC, AGC, CAG, CAA, GTG, CCA, GGG, TTT, GAT, GAG, TGG, CTG, TGG, GTG, CTG, GCG, TAT, CCG, GGG, ATT, AAA, GTC, TCG, ACG, GCA, GAA, GCC, AGG, GCT, ATT, TTA, CCG, GCG, CAG, TAT, CGC, CGC, CAG, GAT, TGC, ATT, GCG, CAC, GGG, CGA, CAT, CTG, GCA, GGC, TTC, ATT, CAC, GCC, TGC, TAT, TCC, CGT, CAG, CTT, GAG, CTT, GCC, GCG, AAG, CTG, ATG, AAA, GAT, GTT, ATC, GCT, GAA, CCC, TAC, CGT, GAA, CGG, TTA, CTG, CCA, GGC, TTC, CGG, CAG, GCG, CGG, CAG, GCG, GTT, GCG, GAA, ATC, GGC, GCG, GTA, GCG, AGC, GGT, ATC, TCC, GGC, TCC, GGC, CCG, ACT, TTG, TTC, GCT, CTG, TGT, GAC, AAG, CCG, GAT, ACC, GCC, CAG, CGC, GTT, GCC, GAC, TGG, TTG, GGT, AAG, AAC, TAC, CTG, CAA, AAT, CAG, GAA, GGT, TTT, GTT, CAT, ATT, TGC, CGG, CTG, GAT, ACG, GCG, GGC, GCA, CGA, GTA, CTG, GAA, AAC, TAA]
+Is Protein?: YES
+
+Region Name: threonine synthase
+Nucleotides: ATGAAACTCTACAATCTGAAAGATCACAATGAGCAGGTCAGCTTTGCGCAAGCCGTAACCCAGGGGTTAGGCAAAAATCAGGGGCTGTTTTTTCCGCACGACCTGCCGGAATTCAGCCTGACTGAAATTGATGAGATGCTGAAGCTGGATTTTGTCACCCGCAGTGCGAAGATCCTCTCGGCGTTTATTGGTGATGAAATCCCGCAGGAAATCCTGGAAGAGCGCGTACGTGCGGCGTTTGCCTTCCCGGCTCCGGTCGCCAATGTTGAAAGCGATGTCGGTTGTCTGGAATTGTTCCACGGGCCAACGCTGGCATTTAAAGATTTCGGCGGTCGCTTTATGGCACAAATGCTGACCCATATTGCGGGCGATAAGCCAGTGACCATTCTGACCGCGACATCCGGTGATACTGGAGCGGCAGTGGCTCATGCTTTCTACGGTTTACCGAATGTGAAAGTGGTTATCCTCTATCCACGAGGCAAAATCAGTCCACTGCAAGAAAAACTGTTCTGTACATTGGGCGGCAATATCGAAACTGTTGCCATCGACGGCGATTTCGATGCCTGTCAGGCGCTGGTGAAGCAGGCGTTTGATGATGAAGAACTGAAAGTGGCGCTGGGGCTGAATTCTGCTAACTCCATCAACATCAGTCGCTTGCTGGCGCAGATTTGTTATTACTTTGAGGCTGTCGCACAGTTGCCGCAAGAAGCACGTAACCAGTTGGTTGTCTCGGTACCGAGTGGAAACTTCGGCGATTTGACGGCGGGTCTGCTGGCGAAGTCACTCGGTCTGCCGGTAAAACGTTTTATTGCTGCGACCAACGTGAACGATACCGTACCACGTTTCCTGCACGACGGTCAGTGGTCACCCAAAGCGACTCAGGCGACGTTATCCAATGCGATGGATGTTAGCCAGCCAAACAACTGGCCGCGTGTGGAAGAGTTGTTCCGCCGCAAAATCTGGCAACTGAAAGAGCTGGGTTATGCAGCCGTGGATGATGAAACCACGCAACAGACAATGCGTGAGTTAAAAGAACTGGGCTATACCTCGGAGCCGCACGCTGCCGTAGCTTATCGTGCGCTGCGTGACCAGTTGAATCCAGGCGAATATGGCTTGTTCCTCGGCACCGCGCATCCGGCGAAATTTAAAGAGAGCGTGGAAGCGATTCTCGGTGAAACGTTGGATCTGCCAAAAGAGCTGGCAGAACGTGCTGATTTACCCTTGCTTTCGCATAACCTGCCCGCCGATTTTGCTGCGTTGCGTAAATTGATGATGAATCATCAGTAA
+Nuc. Counts: [309, 311, 358, 309]
+Total Mass%: [24.7, 20.4, 32.0, 22.9] of 169069.5
+Codons List: [ATG, AAA, CTC, TAC, AAT, CTG, AAA, GAT, CAC, AAT, GAG, CAG, GTC, AGC, TTT, GCG, CAA, GCC, GTA, ACC, CAG, GGG, TTA, GGC, AAA, AAT, CAG, GGG, CTG, TTT, TTT, CCG, CAC, GAC, CTG, CCG, GAA, TTC, AGC, CTG, ACT, GAA, ATT, GAT, GAG, ATG, CTG, AAG, CTG, GAT, TTT, GTC, ACC, CGC, AGT, GCG, AAG, ATC, CTC, TCG, GCG, TTT, ATT, GGT, GAT, GAA, ATC, CCG, CAG, GAA, ATC, CTG, GAA, GAG, CGC, GTA, CGT, GCG, GCG, TTT, GCC, TTC, CCG, GCT, CCG, GTC, GCC, AAT, GTT, GAA, AGC, GAT, GTC, GGT, TGT, CTG, GAA, TTG, TTC, CAC, GGG, CCA, ACG, CTG, GCA, TTT, AAA, GAT, TTC, GGC, GGT, CGC, TTT, ATG, GCA, CAA, ATG, CTG, ACC, CAT, ATT, GCG, GGC, GAT, AAG, CCA, GTG, ACC, ATT, CTG, ACC, GCG, ACA, TCC, GGT, GAT, ACT, GGA, GCG, GCA, GTG, GCT, CAT, GCT, TTC, TAC, GGT, TTA, CCG, AAT, GTG, AAA, GTG, GTT, ATC, CTC, TAT, CCA, CGA, GGC, AAA, ATC, AGT, CCA, CTG, CAA, GAA, AAA, CTG, TTC, TGT, ACA, TTG, GGC, GGC, AAT, ATC, GAA, ACT, GTT, GCC, ATC, GAC, GGC, GAT, TTC, GAT, GCC, TGT, CAG, GCG, CTG, GTG, AAG, CAG, GCG, TTT, GAT, GAT, GAA, GAA, CTG, AAA, GTG, GCG, CTG, GGG, CTG, AAT, TCT, GCT, AAC, TCC, ATC, AAC, ATC, AGT, CGC, TTG, CTG, GCG, CAG, ATT, TGT, TAT, TAC, TTT, GAG, GCT, GTC, GCA, CAG, TTG, CCG, CAA, GAA, GCA, CGT, AAC, CAG, TTG, GTT, GTC, TCG, GTA, CCG, AGT, GGA, AAC, TTC, GGC, GAT, TTG, ACG, GCG, GGT, CTG, CTG, GCG, AAG, TCA, CTC, GGT, CTG, CCG, GTA, AAA, CGT, TTT, ATT, GCT, GCG, ACC, AAC, GTG, AAC, GAT, ACC, GTA, CCA, CGT, TTC, CTG, CAC, GAC, GGT, CAG, TGG, TCA, CCC, AAA, GCG, ACT, CAG, GCG, ACG, TTA, TCC, AAT, GCG, ATG, GAT, GTT, AGC, CAG, CCA, AAC, AAC, TGG, CCG, CGT, GTG, GAA, GAG, TTG, TTC, CGC, CGC, AAA, ATC, TGG, CAA, CTG, AAA, GAG, CTG, GGT, TAT, GCA, GCC, GTG, GAT, GAT, GAA, ACC, ACG, CAA, CAG, ACA, ATG, CGT, GAG, TTA, AAA, GAA, CTG, GGC, TAT, ACC, TCG, GAG, CCG, CAC, GCT, GCC, GTA, GCT, TAT, CGT, GCG, CTG, CGT, GAC, CAG, TTG, AAT, CCA, GGC, GAA, TAT, GGC, TTG, TTC, CTC, GGC, ACC, GCG, CAT, CCG, GCG, AAA, TTT, AAA, GAG, AGC, GTG, GAA, GCG, ATT, CTC, GGT, GAA, ACG, TTG, GAT, CTG, CCA, AAA, GAG, CTG, GCA, GAA, CGT, GCT, GAT, TTA, CCC, TTG, CTT, TCG, CAT, AAC, CTG, CCC, GCC, GAT, TTT, GCT, GCG, TTG, CGT, AAA, TTG, ATG, ATG, AAT, CAT, CAG, TAA]
+Is Protein?: YES
+
+Region Name: hypothetical protein
+Nucleotides: ATGCAGCCCGGCTTTTTTTATGAAGAAAATATGGAGAAAAACGACAGGGAAAAAGGAGAAATTCTCAATAAATGCGGTAACTTAGAGATTAGGATTGCGGAGAATAACAACTGCCGTTCTCATCGCGTAATCTCCGGATATCGACCCATAACGGGCAATGATAAAAGGAGTAACCTGTGA
+Nuc. Counts: [66, 31, 43, 40]
+Total Mass%: [37.4, 14.4, 27.2, 21.0] of 23865.4
+Codons List: [ATG, CAG, CCC, GGC, TTT, TTT, TAT, GAA, GAA, AAT, ATG, GAG, AAA, AAC, GAC, AGG, GAA, AAA, GGA, GAA, ATT, CTC, AAT, AAA, TGC, GGT, AAC, TTA, GAG, ATT, AGG, ATT, GCG, GAG, AAT, AAC, AAC, TGC, CGT, TCT, CAT, CGC, GTA, ATC, TCC, GGA, TAT, CGA, CCC, ATA, ACG, GGC, AAT, GAT, AAA, AGG, AGT, AAC, CTG, TGA]
+Is Protein?: YES
+
+Region Name: Non-protein region
+Nucleotides: AAAAACTGCTGGAAACAATGAAAGACGTACCGGACGACCAACGTCAGGCGC
+Nuc. Counts: [20, 13, 13, 5]
+Total Mass%: [40.1, 21.4, 29.2, 9.3] of 6737.1
+Codons List: [AAA, AAC, TGC, TGG, AAA, CAA, TGA, AAG, ACG, TAC, CGG, ACG, ACC, AAC, GTC, AGG, CGC]
+Is Protein?: NO
+
+Region Name: transaldolase B
+Nucleotides: ATGACGGACAAATTGACCTCCCTTCGTCAGTACACCACCGTAGTGGCCGACACTGGGGACATCGCGGCAATGAAGCTGTATCAACCGCAGGATGCCACAACCAACCCTTCTCTCATTCTTAACGCAGCGCAGATTCCGGAATACCGTAAGTTGATTGATGATGCTGTCGCCTGGGCGAAACAGCAGAGCAACGATCGCGCGCAGCAGATCGTGGACGCGACCGACAAACTGGCAGTAAATATTGGTCTGGAAATCCTGAAACTGGTTCCGGGCCGTATCTCAACTGAAGTTGATGCGCGTCTTTCCTATGACACCGAAGCGTCAATTGCGAAAGCAAAACGCCTGATCAAACTCTACAACGATGCAGGTATTAGCAACGATCGTATTCTGATCAAACTGGCTTCTACCTGGCAGGGTATCCGTGCTGCAGAACAGCTGGAAAAAGAAGGTATTAACTGTAACCTGACCCTGCTGTTCTCCTTCGCTCAGGCTCGTGCTTGTGCGGAAGCGGGCGTGTTCCTGATCTCGCCGTTTGTTGGCCGTATTCTTGACTGGTACAAAGCGAATACCGATAAGAAAGAGTACGCTCCGGCAGAAGATCCGGGCGTGGTTTCTGTATCTGAAATCTACCAGTACTACAAAGAGCATGGTTATGAAACCGTGGTTATGGGCGCAAGCTTCCGTAACATCGGCGAAATTCTGGAACTGGCAGGCTGCGACCGTCTGACCATCGCACCGGCACTGCTGAAAGAGCTGGCGGAGAGCGAAGGGGCTATCGAACGTAAACTGTCTTACACTGGTGAAGTGAAAGCGCGTCCGGCGCGTATCACTGAGTCCGAGTTCCTGTGGCAGCACAACCAGGATCCAATGGCAGTAGATAAACTGGCGGAAGGTATCCGTAAGTTTGCTGTTGACCAGGAAAAACTGGAAAAAATGATCGGCGATCTGCTGTAA
+Nuc. Counts: [252, 236, 256, 210]
+Total Mass%: [27.2, 20.9, 30.9, 21.0] of 125233.8
+Codons List: [ATG, ACG, GAC, AAA, TTG, ACC, TCC, CTT, CGT, CAG, TAC, ACC, ACC, GTA, GTG, GCC, GAC, ACT, GGG, GAC, ATC, GCG, GCA, ATG, AAG, CTG, TAT, CAA, CCG, CAG, GAT, GCC, ACA, ACC, AAC, CCT, TCT, CTC, ATT, CTT, AAC, GCA, GCG, CAG, ATT, CCG, GAA, TAC, CGT, AAG, TTG, ATT, GAT, GAT, GCT, GTC, GCC, TGG, GCG, AAA, CAG, CAG, AGC, AAC, GAT, CGC, GCG, CAG, CAG, ATC, GTG, GAC, GCG, ACC, GAC, AAA, CTG, GCA, GTA, AAT, ATT, GGT, CTG, GAA, ATC, CTG, AAA, CTG, GTT, CCG, GGC, CGT, ATC, TCA, ACT, GAA, GTT, GAT, GCG, CGT, CTT, TCC, TAT, GAC, ACC, GAA, GCG, TCA, ATT, GCG, AAA, GCA, AAA, CGC, CTG, ATC, AAA, CTC, TAC, AAC, GAT, GCA, GGT, ATT, AGC, AAC, GAT, CGT, ATT, CTG, ATC, AAA, CTG, GCT, TCT, ACC, TGG, CAG, GGT, ATC, CGT, GCT, GCA, GAA, CAG, CTG, GAA, AAA, GAA, GGT, ATT, AAC, TGT, AAC, CTG, ACC, CTG, CTG, TTC, TCC, TTC, GCT, CAG, GCT, CGT, GCT, TGT, GCG, GAA, GCG, GGC, GTG, TTC, CTG, ATC, TCG, CCG, TTT, GTT, GGC, CGT, ATT, CTT, GAC, TGG, TAC, AAA, GCG, AAT, ACC, GAT, AAG, AAA, GAG, TAC, GCT, CCG, GCA, GAA, GAT, CCG, GGC, GTG, GTT, TCT, GTA, TCT, GAA, ATC, TAC, CAG, TAC, TAC, AAA, GAG, CAT, GGT, TAT, GAA, ACC, GTG, GTT, ATG, GGC, GCA, AGC, TTC, CGT, AAC, ATC, GGC, GAA, ATT, CTG, GAA, CTG, GCA, GGC, TGC, GAC, CGT, CTG, ACC, ATC, GCA, CCG, GCA, CTG, CTG, AAA, GAG, CTG, GCG, GAG, AGC, GAA, GGG, GCT, ATC, GAA, CGT, AAA, CTG, TCT, TAC, ACT, GGT, GAA, GTG, AAA, GCG, CGT, CCG, GCG, CGT, ATC, ACT, GAG, TCC, GAG, TTC, CTG, TGG, CAG, CAC, AAC, CAG, GAT, CCA, ATG, GCA, GTA, GAT, AAA, CTG, GCG, GAA, GGT, ATC, CGT, AAG, TTT, GCT, GTT, GAC, CAG, GAA, AAA, CTG, GAA, AAA, ATG, ATC, GGC, GAT, CTG, CTG, TAA]
+Is Protein?: YES
+
+Region Name: molybdopterin biosynthesis mog protein
+Nucleotides: ATGAATACTTTACGTATTGGCTTAGTTTCCATCTCTGATCGCGCATCCAGCGGCGTTTATCAGGATAAAGGCATCCCTGCGCTGGAAGAATGGCTGACATCGGCGCTAACCACGCCGTTTGAACTGGAAACCCGCTTAATCCCCGATGAGCAGGCGATCATCGAGCAAACGTTGTGTGAGCTGGTGGATGAAATGAGTTGCCATCTGGTGCTCACCACGGGCGGAACTGGCCCTGCGCGTCGTGACGTAACGCCCGATGCGACGCTGGCAGTAGCGGACCGCGAGATGCCAGGCTTTGGTGAACAGATGCGCCAGATCAGCCTGCATTTTGTACCAACTGCGATCCTTTCGCGTCAGGTGGGGGTGATTCGCAAACAGGCGCTGATCCTTAACTTACCCGGTCAACCGAAGTCTATTAAAGAGACGCTGGAAGGTGTGAAGGACGCTGAGGGTAACGTTGTGGTGCACGGTATTTTTGCCAGCGTACCGTACTGCATTCAGTTGCTGGAAGGGCCATACGTTGAAACGGCACCGGAAGTGGTTGCAGCATTCAGACCGAAGAGTGCAAGACGCGAAGTTAGCGAATAA
+Nuc. Counts: [139, 143, 175, 131]
+Total Mass%: [24.2, 20.5, 34.1, 21.1] of 77506.9
+Codons List: [ATG, AAT, ACT, TTA, CGT, ATT, GGC, TTA, GTT, TCC, ATC, TCT, GAT, CGC, GCA, TCC, AGC, GGC, GTT, TAT, CAG, GAT, AAA, GGC, ATC, CCT, GCG, CTG, GAA, GAA, TGG, CTG, ACA, TCG, GCG, CTA, ACC, ACG, CCG, TTT, GAA, CTG, GAA, ACC, CGC, TTA, ATC, CCC, GAT, GAG, CAG, GCG, ATC, ATC, GAG, CAA, ACG, TTG, TGT, GAG, CTG, GTG, GAT, GAA, ATG, AGT, TGC, CAT, CTG, GTG, CTC, ACC, ACG, GGC, GGA, ACT, GGC, CCT, GCG, CGT, CGT, GAC, GTA, ACG, CCC, GAT, GCG, ACG, CTG, GCA, GTA, GCG, GAC, CGC, GAG, ATG, CCA, GGC, TTT, GGT, GAA, CAG, ATG, CGC, CAG, ATC, AGC, CTG, CAT, TTT, GTA, CCA, ACT, GCG, ATC, CTT, TCG, CGT, CAG, GTG, GGG, GTG, ATT, CGC, AAA, CAG, GCG, CTG, ATC, CTT, AAC, TTA, CCC, GGT, CAA, CCG, AAG, TCT, ATT, AAA, GAG, ACG, CTG, GAA, GGT, GTG, AAG, GAC, GCT, GAG, GGT, AAC, GTT, GTG, GTG, CAC, GGT, ATT, TTT, GCC, AGC, GTA, CCG, TAC, TGC, ATT, CAG, TTG, CTG, GAA, GGG, CCA, TAC, GTT, GAA, ACG, GCA, CCG, GAA, GTG, GTT, GCA, GCA, TTC, AGA, CCG, AAG, AGT, GCA, AGA, CGC, GAA, GTT, AGC, GAA, TAA]
+Is Protein?: YES
+
+Region Name: chaperone protein DnaK
+Nucleotides: ATGGGTAAAATAATTGGTATCGACCTGGGTACTACCAACTCTTGTGTAGCGATTATGGATGGCACCACTCCTCGTGTACTGGAGAACGCCGAAGGCGATCGCACCACGCCTTCTATCATTGCCTATACCCAGGATGGTGAAACTCTGGTTGGTCAGCCGGCTAAACGTCAGGCAGTGACGAACCCGCAAAACACCCTGTTTGCGATTAAACGCCTGATTGGCCGCCGCTTCCAGGACGAAGAAGTACAGCGTGATGTTTCCATCATGCCGTTCAAAATTATTGCTGCTGATAACGGCGACGCATGGGTCGAAGTTAAAGGCCAGAAAATGGCACCGCCGCAGATCTCTGCTGAAGTGCTGAAAAAAATGAAGAAAACCGCTGAAGATTACCTGGGTGAACCGGTAACTGAAGCTGTTATTACCGTACCGGCATACTTTAACGATGCTCAGCGTCAGGCAACCAAAGACGCAGGCCGTATCGCTGGTCTGGAAGTAAAACGTATCATCAACGAACCGACCGCAGCTGCGCTGGCTTACGGTCTGGACAAAGGTACTGGCAACCGTACTATCGCGGTTTATGACCTGGGTGGTGGTACTTTCGATATTTCCATTATCGAAATCGACGAAGTTGACGGCGAAAAAACCTTCGAAGTTCTGGCAACCAACGGTGATACCCACCTGGGTGGTGAAGACTTCGACAGTCGTCTGATCAACTATCTGGTTGAAGAATTCAAGAAAGATCAGGGCATTGACCTGCGCAACGATCCGCTGGCAATGCAGCGCCTGAAAGAAGCGGCAGAAAAAGCGAAAATCGAACTGTCTTCCGCTCAGCAGACCGACGTTAACCTGCCGTACATCACTGCAGACGCGACCGGTCCGAAACACATGAACATCAAAGTGACTCGTGCGAAACTGGAAAGCCTGGTTGAAGATCTGGTAAACCGTTCCATTGAGCCGCTGAAAGTTGCACTGCAGGACGCTGGCCTGTCCGTATCTGATATCGACGACGTTATTCTCGTTGGTGGTCAGACTCGTATGCCAATGGTTCAGAAGAAAGTTGCTGAATTCTTTGGTAAAGAGCCGCGTAAAGATGTTAACCCGGACGAAGCTGTAGCCATCGGTGCTGCTGTTCAGGGTGGTGTTCTGACTGGTGACGTAAAAGACGTACTGCTGCTGGACGTTACCCCGCTGTCTCTGGGTATCGAAACCATGGGCGGTGTGATGACCACGCTGATCGCGAAAAACACCACTATCCCGACCAAGCACAGCCAGGTGTTCTCTACCGCTGAAGACAACCAGTCTGCGGTAACCATCCATGTGCTGCAGGGTGAACGTAAACGTGCGGCTGATAACAAATCTCTGGGTCAGTTCAACCTGGATGGTATCAACCCGGCACCGCGCGGCATGCCGCAGATCGAAGTTACCTTCGATATCGATGCTGACGGTATCCTGCACGTTTCCGCGAAAGACAAAAACAGCGGTAAAGAGCAGAAGATCACTATCAAGGCTTCTTCTGGTCTGAACGAAGATGAAATCCAGAAAATGGTACGCGACGCAGAAGCTAACGCCGAAGCTGACCGTAAGTTTGAAGAGCTGGTACAGACTCGCAACCAGGGCGACCATCTGCTGCACAGCACCCGTAAGCAGGTTGAAGAAGCAGGCGACAAACTGCCGGCTGACGACAAAACTGCTATCGAGTCTGCGCTGACTGCACTGGAAACTGCTCTGAAAGGTGAAGACAAAGCCGCTATCGAAGCGAAAATGCAGGAACTGGCACAGGTTTCCCAGAAACTGATGGAAATCGCCCAGCAGCAACATGCCCAGCAGCAGACTGCCGGTGCTGATGCTTCTGCAAACAACGCGAAAGATGACGATGTTGTCGACGCTGAATTTGAAGAAGTCAAAGACAAAAAATAA
+Nuc. Counts: [541, 475, 504, 397]
+Total Mass%: [29.0, 21.0, 30.3, 19.7] of 251714.2
+Codons List: [ATG, GGT, AAA, ATA, ATT, GGT, ATC, GAC, CTG, GGT, ACT, ACC, AAC, TCT, TGT, GTA, GCG, ATT, ATG, GAT, GGC, ACC, ACT, CCT, CGT, GTA, CTG, GAG, AAC, GCC, GAA, GGC, GAT, CGC, ACC, ACG, CCT, TCT, ATC, ATT, GCC, TAT, ACC, CAG, GAT, GGT, GAA, ACT, CTG, GTT, GGT, CAG, CCG, GCT, AAA, CGT, CAG, GCA, GTG, ACG, AAC, CCG, CAA, AAC, ACC, CTG, TTT, GCG, ATT, AAA, CGC, CTG, ATT, GGC, CGC, CGC, TTC, CAG, GAC, GAA, GAA, GTA, CAG, CGT, GAT, GTT, TCC, ATC, ATG, CCG, TTC, AAA, ATT, ATT, GCT, GCT, GAT, AAC, GGC, GAC, GCA, TGG, GTC, GAA, GTT, AAA, GGC, CAG, AAA, ATG, GCA, CCG, CCG, CAG, ATC, TCT, GCT, GAA, GTG, CTG, AAA, AAA, ATG, AAG, AAA, ACC, GCT, GAA, GAT, TAC, CTG, GGT, GAA, CCG, GTA, ACT, GAA, GCT, GTT, ATT, ACC, GTA, CCG, GCA, TAC, TTT, AAC, GAT, GCT, CAG, CGT, CAG, GCA, ACC, AAA, GAC, GCA, GGC, CGT, ATC, GCT, GGT, CTG, GAA, GTA, AAA, CGT, ATC, ATC, AAC, GAA, CCG, ACC, GCA, GCT, GCG, CTG, GCT, TAC, GGT, CTG, GAC, AAA, GGT, ACT, GGC, AAC, CGT, ACT, ATC, GCG, GTT, TAT, GAC, CTG, GGT, GGT, GGT, ACT, TTC, GAT, ATT, TCC, ATT, ATC, GAA, ATC, GAC, GAA, GTT, GAC, GGC, GAA, AAA, ACC, TTC, GAA, GTT, CTG, GCA, ACC, AAC, GGT, GAT, ACC, CAC, CTG, GGT, GGT, GAA, GAC, TTC, GAC, AGT, CGT, CTG, ATC, AAC, TAT, CTG, GTT, GAA, GAA, TTC, AAG, AAA, GAT, CAG, GGC, ATT, GAC, CTG, CGC, AAC, GAT, CCG, CTG, GCA, ATG, CAG, CGC, CTG, AAA, GAA, GCG, GCA, GAA, AAA, GCG, AAA, ATC, GAA, CTG, TCT, TCC, GCT, CAG, CAG, ACC, GAC, GTT, AAC, CTG, CCG, TAC, ATC, ACT, GCA, GAC, GCG, ACC, GGT, CCG, AAA, CAC, ATG, AAC, ATC, AAA, GTG, ACT, CGT, GCG, AAA, CTG, GAA, AGC, CTG, GTT, GAA, GAT, CTG, GTA, AAC, CGT, TCC, ATT, GAG, CCG, CTG, AAA, GTT, GCA, CTG, CAG, GAC, GCT, GGC, CTG, TCC, GTA, TCT, GAT, ATC, GAC, GAC, GTT, ATT, CTC, GTT, GGT, GGT, CAG, ACT, CGT, ATG, CCA, ATG, GTT, CAG, AAG, AAA, GTT, GCT, GAA, TTC, TTT, GGT, AAA, GAG, CCG, CGT, AAA, GAT, GTT, AAC, CCG, GAC, GAA, GCT, GTA, GCC, ATC, GGT, GCT, GCT, GTT, CAG, GGT, GGT, GTT, CTG, ACT, GGT, GAC, GTA, AAA, GAC, GTA, CTG, CTG, CTG, GAC, GTT, ACC, CCG, CTG, TCT, CTG, GGT, ATC, GAA, ACC, ATG, GGC, GGT, GTG, ATG, ACC, ACG, CTG, ATC, GCG, AAA, AAC, ACC, ACT, ATC, CCG, ACC, AAG, CAC, AGC, CAG, GTG, TTC, TCT, ACC, GCT, GAA, GAC, AAC, CAG, TCT, GCG, GTA, ACC, ATC, CAT, GTG, CTG, CAG, GGT, GAA, CGT, AAA, CGT, GCG, GCT, GAT, AAC, AAA, TCT, CTG, GGT, CAG, TTC, AAC, CTG, GAT, GGT, ATC, AAC, CCG, GCA, CCG, CGC, GGC, ATG, CCG, CAG, ATC, GAA, GTT, ACC, TTC, GAT, ATC, GAT, GCT, GAC, GGT, ATC, CTG, CAC, GTT, TCC, GCG, AAA, GAC, AAA, AAC, AGC, GGT, AAA, GAG, CAG, AAG, ATC, ACT, ATC, AAG, GCT, TCT, TCT, GGT, CTG, AAC, GAA, GAT, GAA, ATC, CAG, AAA, ATG, GTA, CGC, GAC, GCA, GAA, GCT, AAC, GCC, GAA, GCT, GAC, CGT, AAG, TTT, GAA, GAG, CTG, GTA, CAG, ACT, CGC, AAC, CAG, GGC, GAC, CAT, CTG, CTG, CAC, AGC, ACC, CGT, AAG, CAG, GTT, GAA, GAA, GCA, GGC, GAC, AAA, CTG, CCG, GCT, GAC, GAC, AAA, ACT, GCT, ATC, GAG, TCT, GCG, CTG, ACT, GCA, CTG, GAA, ACT, GCT, CTG, AAA, GGT, GAA, GAC, AAA, GCC, GCT, ATC, GAA, GCG, AAA, ATG, CAG, GAA, CTG, GCA, CAG, GTT, TCC, CAG, AAA, CTG, ATG, GAA, ATC, GCC, CAG, CAG, CAA, CAT, GCC, CAG, CAG, CAG, ACT, GCC, GGT, GCT, GAT, GCT, TCT, GCA, AAC, AAC, GCG, AAA, GAT, GAC, GAT, GTT, GTC, GAC, GCT, GAA, TTT, GAA, GAA, GTC, AAA, GAC, AAA, AAA, TAA]
+Is Protein?: YES
+
+Region Name: chaperone protein DnaJ
+Nucleotides: GTGCATTCATCTAGGGGCAATTTAAAAAAGATGGCTAAGCAAGATTATTACGAGATTTTAGGCGTTTCCAAAACAGCGGAAGAGCGTGAAATCAAAAAGGCCTACAAACGCCTGGCCATGAAATACCACCCGGACCGTAACCAGGGTGACAAAGAGGCCGAGGCGAAATTTAAAGAGATCAAGGAAGCTTATGAAGTTCTGACCGACTCGCAAAAACGTGCGGCATACGATCAGTATGGTCATGCTGCGTTTGAGCAAGGTGGCATGGGCGGCGGCGGTTTTGGCGGCGGCGCAGACTTCAGCGATATTTTTGGTGACGTTTTCGGCGATATTTTTGGCGGCGGACGTGGTCGTCAACGTGCGGCGCGCGGTGCTGATTTACGCTATAACATGGAGCTCACCCTCGAAGAAGCTGTACGTGGCGTGACCAAAGAGATCCGCATTCCGACTCTGGAAGAGTGTGACGTTTGCCACGGTAGCGGTGCAAAACCAGGTACACAGCCGCAGACCTGTCCGACCTGTCATGGTTCTGGCCAGGTGCAGATGCGCCAGGGTTTCTTTGCCGTGCAGCAGACCTGTCCACACTGTCAGGGCCGCGGTACGCTGATCAAAGATCCGTGCAACAAATGTCATGGTCATGGTCGTGTTGAGCGCAGCAAAACGCTGTCCGTTAAAATCCCGGCAGGGGTGGACACTGGAGACCGCATCCGTCTTGCGGGCGAAGGTGAAGCGGGTGAACACGGCGCACCGGCAGGCGATCTGTACGTTCAGGTTCAGGTTAAACAGCACCCGATTTTCGAGCGTGAAGGCAACAACCTGTATTGCGAAGTCCCGATCAACTTCGCTATGGCGGCGCTGGGTGGTGAAATCGAAGTACCGACCCTTGATGGTCGCGTCAAACTGAAAGTGCCTGGCGAAACCCAGACCGGTAAGCTGTTCCGTATGCGCGGTAAAGGCGTCAAGTCTGTCCGCGGTGGCGCACAGGGTGATTTGCTATGCCGCGTTGTTGTCGAAACACCGGTAGGTTTGAACGAGAAGCAGAAACAGCTGCTGCAAGAGCTGCAAGAAAGCTTTGGTGGCCCAACCGGCGAGCACAACAGCCCGCGTTCAAAGAGCTTCTTTGATGGCGTGAAGAAGTTTTTTGACGACCTGACTCGCTAA
+Nuc. Counts: [287, 278, 352, 244]
+Total Mass%: [25.3, 20.1, 34.7, 19.9] of 153391.5
+Codons List: [GTG, CAT, TCA, TCT, AGG, GGC, AAT, TTA, AAA, AAG, ATG, GCT, AAG, CAA, GAT, TAT, TAC, GAG, ATT, TTA, GGC, GTT, TCC, AAA, ACA, GCG, GAA, GAG, CGT, GAA, ATC, AAA, AAG, GCC, TAC, AAA, CGC, CTG, GCC, ATG, AAA, TAC, CAC, CCG, GAC, CGT, AAC, CAG, GGT, GAC, AAA, GAG, GCC, GAG, GCG, AAA, TTT, AAA, GAG, ATC, AAG, GAA, GCT, TAT, GAA, GTT, CTG, ACC, GAC, TCG, CAA, AAA, CGT, GCG, GCA, TAC, GAT, CAG, TAT, GGT, CAT, GCT, GCG, TTT, GAG, CAA, GGT, GGC, ATG, GGC, GGC, GGC, GGT, TTT, GGC, GGC, GGC, GCA, GAC, TTC, AGC, GAT, ATT, TTT, GGT, GAC, GTT, TTC, GGC, GAT, ATT, TTT, GGC, GGC, GGA, CGT, GGT, CGT, CAA, CGT, GCG, GCG, CGC, GGT, GCT, GAT, TTA, CGC, TAT, AAC, ATG, GAG, CTC, ACC, CTC, GAA, GAA, GCT, GTA, CGT, GGC, GTG, ACC, AAA, GAG, ATC, CGC, ATT, CCG, ACT, CTG, GAA, GAG, TGT, GAC, GTT, TGC, CAC, GGT, AGC, GGT, GCA, AAA, CCA, GGT, ACA, CAG, CCG, CAG, ACC, TGT, CCG, ACC, TGT, CAT, GGT, TCT, GGC, CAG, GTG, CAG, ATG, CGC, CAG, GGT, TTC, TTT, GCC, GTG, CAG, CAG, ACC, TGT, CCA, CAC, TGT, CAG, GGC, CGC, GGT, ACG, CTG, ATC, AAA, GAT, CCG, TGC, AAC, AAA, TGT, CAT, GGT, CAT, GGT, CGT, GTT, GAG, CGC, AGC, AAA, ACG, CTG, TCC, GTT, AAA, ATC, CCG, GCA, GGG, GTG, GAC, ACT, GGA, GAC, CGC, ATC, CGT, CTT, GCG, GGC, GAA, GGT, GAA, GCG, GGT, GAA, CAC, GGC, GCA, CCG, GCA, GGC, GAT, CTG, TAC, GTT, CAG, GTT, CAG, GTT, AAA, CAG, CAC, CCG, ATT, TTC, GAG, CGT, GAA, GGC, AAC, AAC, CTG, TAT, TGC, GAA, GTC, CCG, ATC, AAC, TTC, GCT, ATG, GCG, GCG, CTG, GGT, GGT, GAA, ATC, GAA, GTA, CCG, ACC, CTT, GAT, GGT, CGC, GTC, AAA, CTG, AAA, GTG, CCT, GGC, GAA, ACC, CAG, ACC, GGT, AAG, CTG, TTC, CGT, ATG, CGC, GGT, AAA, GGC, GTC, AAG, TCT, GTC, CGC, GGT, GGC, GCA, CAG, GGT, GAT, TTG, CTA, TGC, CGC, GTT, GTT, GTC, GAA, ACA, CCG, GTA, GGT, TTG, AAC, GAG, AAG, CAG, AAA, CAG, CTG, CTG, CAA, GAG, CTG, CAA, GAA, AGC, TTT, GGT, GGC, CCA, ACC, GGC, GAG, CAC, AAC, AGC, CCG, CGT, TCA, AAG, AGC, TTC, TTT, GAT, GGC, GTG, AAG, AAG, TTT, TTT, GAC, GAC, CTG, ACT, CGC, TAA]
+Is Protein?: NO
+
+Region Name: hypothetical protein
+Nucleotides: TTGCTCTTACTCGGATTCGTAAGCCGTGAAAACAGCAACCTCCGTCTGGCCAGTTCGGATGTGAACCTCACAGAGGTCTTTTCTCGTTACCAGCGCCGCCACTACGGCGGTGATACAGATGACGATCAGGGCGACAATCATCGCCTTATGCTGCTTCATTGCTCTCTTCTCCTTGACCTTTCGGTCAGTAAGAGGCACTCTACATGTGTTCTGCATATAGGGGGCCTCGGGTTGATGGTAAAATATCACTCGGGGCTTTTCTCTATCTGCCGTTCAGCTAATGCCTGA
+Nuc. Counts: [58, 78, 69, 83]
+Total Mass%: [21.0, 23.2, 27.9, 27.8] of 37315.2
+Codons List: [TTG, CTC, TTA, CTC, GGA, TTC, GTA, AGC, CGT, GAA, AAC, AGC, AAC, CTC, CGT, CTG, GCC, AGT, TCG, GAT, GTG, AAC, CTC, ACA, GAG, GTC, TTT, TCT, CGT, TAC, CAG, CGC, CGC, CAC, TAC, GGC, GGT, GAT, ACA, GAT, GAC, GAT, CAG, GGC, GAC, AAT, CAT, CGC, CTT, ATG, CTG, CTT, CAT, TGC, TCT, CTT, CTC, CTT, GAC, CTT, TCG, GTC, AGT, AAG, AGG, CAC, TCT, ACA, TGT, GTT, CTG, CAT, ATA, GGG, GGC, CTC, GGG, TTG, ATG, GTA, AAA, TAT, CAC, TCG, GGG, CTT, TTC, TCT, ATC, TGC, CGT, TCA, GCT, AAT, GCC, TGA]
+Is Protein?: NO
+
+Region Name: hypothetical protein
+Nucleotides: ATGTCTGCCAAAAGACGACTTCTTATTGCGTGTACCTTGATAACAGCTATCTATCATTTTCCTGCATATTCTTCATTAGAATATAAAGGATCCTTTGGTTCAATAAATGCGGGTTATGCAGACTGGAATAGTGGATTTGTAAACACTCACCGTGGTGAAGTATGGAAAGTGACTGCGGATTTTGGGGTAAATTTTAAAGAAGCAGAATTTTACTCATTTTATGAAAGTAATGTACTCAATCATGCTGTAGCAGGGAGAAATCATACGGTTTCAGCAATGACGCATGTCAGACTCTTTGACTCTGATATGACATTCTTTGGCAAAATTTATGGCCAATGGGATAACTCATGGGGTGACGATCTGGACATGTTTTATGGATTCGGTTACCTCGGCTGGAACGGCGAGTGGGGCTTTTTTAAACCGTATATTGGATTGCATAATCAATCTGGTGACTACGTATCAGCTAAATATGGTCAAACGAATGGTTGGAATGGTTATGTTGTTGGCTGGACAGCAGTATTACCATTTACGTTATTTGACGAAAAATTTGTTTTATCTAACTGGAATGAAATAGAACTGGACAGGAACGATGCTTACACGGAGCAGCAATTTGGCCGGAACGGGTTAAATGGCGGTTTAACTATTGCCTGGAAGTTCTATCCTCGCTGGAAAGCCAGTGTGACGTGGCGTTATTTCGATAATAAGCTGGGCTACGATGGCTTTGGCGATCAAATGATTTATATGCTTGGTTATGATTTCTAA
+Nuc. Counts: [214, 121, 184, 243]
+Total Mass%: [28.8, 13.4, 27.7, 30.2] of 100569.4
+Codons List: [ATG, TCT, GCC, AAA, AGA, CGA, CTT, CTT, ATT, GCG, TGT, ACC, TTG, ATA, ACA, GCT, ATC, TAT, CAT, TTT, CCT, GCA, TAT, TCT, TCA, TTA, GAA, TAT, AAA, GGA, TCC, TTT, GGT, TCA, ATA, AAT, GCG, GGT, TAT, GCA, GAC, TGG, AAT, AGT, GGA, TTT, GTA, AAC, ACT, CAC, CGT, GGT, GAA, GTA, TGG, AAA, GTG, ACT, GCG, GAT, TTT, GGG, GTA, AAT, TTT, AAA, GAA, GCA, GAA, TTT, TAC, TCA, TTT, TAT, GAA, AGT, AAT, GTA, CTC, AAT, CAT, GCT, GTA, GCA, GGG, AGA, AAT, CAT, ACG, GTT, TCA, GCA, ATG, ACG, CAT, GTC, AGA, CTC, TTT, GAC, TCT, GAT, ATG, ACA, TTC, TTT, GGC, AAA, ATT, TAT, GGC, CAA, TGG, GAT, AAC, TCA, TGG, GGT, GAC, GAT, CTG, GAC, ATG, TTT, TAT, GGA, TTC, GGT, TAC, CTC, GGC, TGG, AAC, GGC, GAG, TGG, GGC, TTT, TTT, AAA, CCG, TAT, ATT, GGA, TTG, CAT, AAT, CAA, TCT, GGT, GAC, TAC, GTA, TCA, GCT, AAA, TAT, GGT, CAA, ACG, AAT, GGT, TGG, AAT, GGT, TAT, GTT, GTT, GGC, TGG, ACA, GCA, GTA, TTA, CCA, TTT, ACG, TTA, TTT, GAC, GAA, AAA, TTT, GTT, TTA, TCT, AAC, TGG, AAT, GAA, ATA, GAA, CTG, GAC, AGG, AAC, GAT, GCT, TAC, ACG, GAG, CAG, CAA, TTT, GGC, CGG, AAC, GGG, TTA, AAT, GGC, GGT, TTA, ACT, ATT, GCC, TGG, AAG, TTC, TAT, CCT, CGC, TGG, AAA, GCC, AGT, GTG, ACG, TGG, CGT, TAT, TTC, GAT, AAT, AAG, CTG, GGC, TAC, GAT, GGC, TTT, GGC, GAT, CAA, ATG, ATT, TAT, ATG, CTT, GGT, TAT, GAT, TTC, TAA]
+Is Protein?: YES
+
+Region Name: putative secreted sulfatase
+Nucleotides: ATGCAGAAAACGTTAATGGCCAGTTTGATCGGCCTTGCAGTTTGCACAGGGAATGCTTTTAGTCCTGCCTTAGCCGCAGAGGCTAAACAACCTAATTTAGTCATTATTATGGCGGATGATTTAGGTTATGGCGATTTAGCAACATATGGTCATCAGATCGTTAAAACACCTAATATCGACAGGCTTGCCCAGGAAGGGGTCAAATTTACTGACTACTATGCCCCCGCTCCTTTAAGTTCACCTTCACGCGCAGGGCTATTAACCGGCCGGATGCCATTTCGTACTGGAATTCGCTCATGGATTCCTTCAGGCAAAGATGTTGCCTTAGGGCGTAACGAACTCACGATTGCTAATCTACTCAAAGCGCAAGGGTACGACACGGCAATGATGGGTAAGCTGCATCTGAATGCAGGCGGCGATCGCACCGATCAGCCACAAGCACAAGATATGGGCTTTGATTACTCACTGGTTAATACGGCGGGCTTTGTTACCGACGCCACGCTGGATAACGCTAAAGAACGCCCGCGTTATGGCATGGTTTACCCGACAGGCTGGCTACGTAACGGGCAACCCACTCCACGAGCTGATAAAATGAGCGGTGAGTATGTCAGTTCGGAAGTCGTCAACTGGCTGGATAACAAAAAGGACAGCAAGCCTTTCTTCCTCTATGTTGCTTTTACCGAAGTGCATAGCCCCCTGGCTTCGCCCAAAAAATACCTCGATATGTACTCACAATATATGAGCGCGTATCAGAAGCAGCATCCTGATTTATTTTATGGCGACTGGGCAGACAAACCCTGGCGTGGTGTGGGGGAATATTATGCCAATATCAGCTATCTGGATGCACAGGTTGGAAAAGTGCTGGATAAAATCAAAGCTGTGGGTGAAGAAGATAACACAATCGTTATTTTTACCAGTGATAACGGTCCGGTAACGCGTGAAGCGCGCAAAGTGTATGAGCTGAATTTGGCAGGGGAAACGGATGGATTACGCGGTCGCAAGGATAACCTTTGGGAAGGCGGAATTCGTGTTCCAGCCATTATTAAATATGGTAAACATCTACCACAGGGAATGGTTTCAGATACACCCGTTTATGGTCTGGACTGGATGCCTACTTTAGCGAAAATGATGAACTTCAAATTACCTACAGACCGTACTTTCGATGGTGAATCGCTGGTTCCTGTTCTTGAGCAAAAAGCATTGAAACGCGAAAAGCCATTAATTTTCGGGATTGATATGCCATTCCAGGATGATCCAACCGATGAATGGGCGATCCGTGATGGTGACTGGAAGATGATTATCGATCGCAATAATAAACCGAAATATCTCTACAATCTGAAATCTGATCGTTATGAAACACTTAATCTGATCGGTAAAAAAACAGATATTGAAAAACAGATGTATGGTAAGTTTTTAAAATATAAAACTGATATTGATAATGATTCTCTAATGAAAGCCAGAGGTGATAAACCAGAAGCGGTGACCTGGGGCTAA
+Nuc. Counts: [440, 312, 362, 380]
+Total Mass%: [30.3, 17.7, 27.9, 24.2] of 196369.5
+Codons List: [ATG, CAG, AAA, ACG, TTA, ATG, GCC, AGT, TTG, ATC, GGC, CTT, GCA, GTT, TGC, ACA, GGG, AAT, GCT, TTT, AGT, CCT, GCC, TTA, GCC, GCA, GAG, GCT, AAA, CAA, CCT, AAT, TTA, GTC, ATT, ATT, ATG, GCG, GAT, GAT, TTA, GGT, TAT, GGC, GAT, TTA, GCA, ACA, TAT, GGT, CAT, CAG, ATC, GTT, AAA, ACA, CCT, AAT, ATC, GAC, AGG, CTT, GCC, CAG, GAA, GGG, GTC, AAA, TTT, ACT, GAC, TAC, TAT, GCC, CCC, GCT, CCT, TTA, AGT, TCA, CCT, TCA, CGC, GCA, GGG, CTA, TTA, ACC, GGC, CGG, ATG, CCA, TTT, CGT, ACT, GGA, ATT, CGC, TCA, TGG, ATT, CCT, TCA, GGC, AAA, GAT, GTT, GCC, TTA, GGG, CGT, AAC, GAA, CTC, ACG, ATT, GCT, AAT, CTA, CTC, AAA, GCG, CAA, GGG, TAC, GAC, ACG, GCA, ATG, ATG, GGT, AAG, CTG, CAT, CTG, AAT, GCA, GGC, GGC, GAT, CGC, ACC, GAT, CAG, CCA, CAA, GCA, CAA, GAT, ATG, GGC, TTT, GAT, TAC, TCA, CTG, GTT, AAT, ACG, GCG, GGC, TTT, GTT, ACC, GAC, GCC, ACG, CTG, GAT, AAC, GCT, AAA, GAA, CGC, CCG, CGT, TAT, GGC, ATG, GTT, TAC, CCG, ACA, GGC, TGG, CTA, CGT, AAC, GGG, CAA, CCC, ACT, CCA, CGA, GCT, GAT, AAA, ATG, AGC, GGT, GAG, TAT, GTC, AGT, TCG, GAA, GTC, GTC, AAC, TGG, CTG, GAT, AAC, AAA, AAG, GAC, AGC, AAG, CCT, TTC, TTC, CTC, TAT, GTT, GCT, TTT, ACC, GAA, GTG, CAT, AGC, CCC, CTG, GCT, TCG, CCC, AAA, AAA, TAC, CTC, GAT, ATG, TAC, TCA, CAA, TAT, ATG, AGC, GCG, TAT, CAG, AAG, CAG, CAT, CCT, GAT, TTA, TTT, TAT, GGC, GAC, TGG, GCA, GAC, AAA, CCC, TGG, CGT, GGT, GTG, GGG, GAA, TAT, TAT, GCC, AAT, ATC, AGC, TAT, CTG, GAT, GCA, CAG, GTT, GGA, AAA, GTG, CTG, GAT, AAA, ATC, AAA, GCT, GTG, GGT, GAA, GAA, GAT, AAC, ACA, ATC, GTT, ATT, TTT, ACC, AGT, GAT, AAC, GGT, CCG, GTA, ACG, CGT, GAA, GCG, CGC, AAA, GTG, TAT, GAG, CTG, AAT, TTG, GCA, GGG, GAA, ACG, GAT, GGA, TTA, CGC, GGT, CGC, AAG, GAT, AAC, CTT, TGG, GAA, GGC, GGA, ATT, CGT, GTT, CCA, GCC, ATT, ATT, AAA, TAT, GGT, AAA, CAT, CTA, CCA, CAG, GGA, ATG, GTT, TCA, GAT, ACA, CCC, GTT, TAT, GGT, CTG, GAC, TGG, ATG, CCT, ACT, TTA, GCG, AAA, ATG, ATG, AAC, TTC, AAA, TTA, CCT, ACA, GAC, CGT, ACT, TTC, GAT, GGT, GAA, TCG, CTG, GTT, CCT, GTT, CTT, GAG, CAA, AAA, GCA, TTG, AAA, CGC, GAA, AAG, CCA, TTA, ATT, TTC, GGG, ATT, GAT, ATG, CCA, TTC, CAG, GAT, GAT, CCA, ACC, GAT, GAA, TGG, GCG, ATC, CGT, GAT, GGT, GAC, TGG, AAG, ATG, ATT, ATC, GAT, CGC, AAT, AAT, AAA, CCG, AAA, TAT, CTC, TAC, AAT, CTG, AAA, TCT, GAT, CGT, TAT, GAA, ACA, CTT, AAT, CTG, ATC, GGT, AAA, AAA, ACA, GAT, ATT, GAA, AAA, CAG, ATG, TAT, GGT, AAG, TTT, TTA, AAA, TAT, AAA, ACT, GAT, ATT, GAT, AAT, GAT, TCT, CTA, ATG, AAA, GCC, AGA, GGT, GAT, AAA, CCA, GAA, GCG, GTG, ACC, TGG, GGC, TAA]
+Is Protein?: YES
+
+Region Name: putative cytoplasmic protein
+Nucleotides: ATGTTTACCAACGTAAATGTTGATTGTTGCAAAACACCAGGATGTAAAAACCTGGGGTTGCTGAATAGCCAGGATTATGTCGCACAGGGTAAAAATATTTTATGCCGTGAATGTGGTTACTTGTTTCCAGTGATATCTGAACAGTCGCTTAATATTTATCGTAATATTGTGAATCACTCCTGGAGAGGTTTGATTTGCCAATGTTCAACTTGCGGAGGCACGTCCCTCAAAAAATATGGATATTCTGCACAAGGCCAGAGAAGAATGTATTGCCATCATTGTGAGAAAACATTTATCACTCTGGAACATGTAATTACCACACCACGAGGAGCCCTGTTAGCATTGATGATTGAGCAAGGGGAGGCACTTGCGGATATCAGAAAGTCATTACGTCTTAACAGCACTGGACTTAGCCGTGAACTGTTAAAATTAGCGCGTGAAGCAAACTATAAAGAAAGTCGACAGTGTTTCCCTGCTTCTGATATTACCCTGAGTACCCGCGCTTTTCGCGTCAAGTATAATGGTAGCAATAACTCTCTTTATGCTCTTGTTACCGCAGAAGAACAAAGCGGCAGGGTGGTTGCCATCTCAACCAATTACTCCCCATCTGCCGTAGAGCAACATTATCAATACACATCGAACTATGAAGAGCGTATGTCTCCAGGGACGCTGGCACATCATGTCCAGCGCAAAGAGTTACTTACTATGCGGCGGGATACCTTGTTTGATATTGATTACGGCCCGGCAGTTTTACATCAAAACGATCCGGGAATGTTGGTAAAACCGGTTCTTCCGGCATATCGTCATTTTGAACTGGTCAGAATACTGACCGATGAGCATTCCAACAACGTTCAGCATTACCTTGATCACGAATGCTTTATATTGGGCGGCTGCCTGATGGCTAATTTGCAGCATATTCATCAAGGTCGCTGCCATATTTCCTTTGTCAAAGAGCGCGGTGTGGCACCCGCCACCATTGATTTTCCACCGCGATTATTCCTTAGTGGTGGGGTACGAAATAATGTCTGGCGTGCATTTTCTAACCGCAATTATTCAATGGCTGTATGCAATCTCACTGGCAGTAAGAAAGTCCGCGAGATGCGGCATGCAACATTGAACAGTGCGACGCGTTTTATCCACTTTGTGGAGAACCATCCTTTCCTTATATCATTGAACCGAATGTCTCCTGCGAATGTCGTTTCTACATTAGATATCCTCAAACATCTGTGGAATAAAAAACTAGAGCATGGAACAATTTAA
+Nuc. Counts: [355, 273, 276, 356]
+Total Mass%: [29.2, 18.4, 25.3, 27.1] of 164551.0
+Codons List: [ATG, TTT, ACC, AAC, GTA, AAT, GTT, GAT, TGT, TGC, AAA, ACA, CCA, GGA, TGT, AAA, AAC, CTG, GGG, TTG, CTG, AAT, AGC, CAG, GAT, TAT, GTC, GCA, CAG, GGT, AAA, AAT, ATT, TTA, TGC, CGT, GAA, TGT, GGT, TAC, TTG, TTT, CCA, GTG, ATA, TCT, GAA, CAG, TCG, CTT, AAT, ATT, TAT, CGT, AAT, ATT, GTG, AAT, CAC, TCC, TGG, AGA, GGT, TTG, ATT, TGC, CAA, TGT, TCA, ACT, TGC, GGA, GGC, ACG, TCC, CTC, AAA, AAA, TAT, GGA, TAT, TCT, GCA, CAA, GGC, CAG, AGA, AGA, ATG, TAT, TGC, CAT, CAT, TGT, GAG, AAA, ACA, TTT, ATC, ACT, CTG, GAA, CAT, GTA, ATT, ACC, ACA, CCA, CGA, GGA, GCC, CTG, TTA, GCA, TTG, ATG, ATT, GAG, CAA, GGG, GAG, GCA, CTT, GCG, GAT, ATC, AGA, AAG, TCA, TTA, CGT, CTT, AAC, AGC, ACT, GGA, CTT, AGC, CGT, GAA, CTG, TTA, AAA, TTA, GCG, CGT, GAA, GCA, AAC, TAT, AAA, GAA, AGT, CGA, CAG, TGT, TTC, CCT, GCT, TCT, GAT, ATT, ACC, CTG, AGT, ACC, CGC, GCT, TTT, CGC, GTC, AAG, TAT, AAT, GGT, AGC, AAT, AAC, TCT, CTT, TAT, GCT, CTT, GTT, ACC, GCA, GAA, GAA, CAA, AGC, GGC, AGG, GTG, GTT, GCC, ATC, TCA, ACC, AAT, TAC, TCC, CCA, TCT, GCC, GTA, GAG, CAA, CAT, TAT, CAA, TAC, ACA, TCG, AAC, TAT, GAA, GAG, CGT, ATG, TCT, CCA, GGG, ACG, CTG, GCA, CAT, CAT, GTC, CAG, CGC, AAA, GAG, TTA, CTT, ACT, ATG, CGG, CGG, GAT, ACC, TTG, TTT, GAT, ATT, GAT, TAC, GGC, CCG, GCA, GTT, TTA, CAT, CAA, AAC, GAT, CCG, GGA, ATG, TTG, GTA, AAA, CCG, GTT, CTT, CCG, GCA, TAT, CGT, CAT, TTT, GAA, CTG, GTC, AGA, ATA, CTG, ACC, GAT, GAG, CAT, TCC, AAC, AAC, GTT, CAG, CAT, TAC, CTT, GAT, CAC, GAA, TGC, TTT, ATA, TTG, GGC, GGC, TGC, CTG, ATG, GCT, AAT, TTG, CAG, CAT, ATT, CAT, CAA, GGT, CGC, TGC, CAT, ATT, TCC, TTT, GTC, AAA, GAG, CGC, GGT, GTG, GCA, CCC, GCC, ACC, ATT, GAT, TTT, CCA, CCG, CGA, TTA, TTC, CTT, AGT, GGT, GGG, GTA, CGA, AAT, AAT, GTC, TGG, CGT, GCA, TTT, TCT, AAC, CGC, AAT, TAT, TCA, ATG, GCT, GTA, TGC, AAT, CTC, ACT, GGC, AGT, AAG, AAA, GTC, CGC, GAG, ATG, CGG, CAT, GCA, ACA, TTG, AAC, AGT, GCG, ACG, CGT, TTT, ATC, CAC, TTT, GTG, GAG, AAC, CAT, CCT, TTC, CTT, ATA, TCA, TTG, AAC, CGA, ATG, TCT, CCT, GCG, AAT, GTC, GTT, TCT, ACA, TTA, GAT, ATC, CTC, AAA, CAT, CTG, TGG, AAT, AAA, AAA, CTA, GAG, CAT, GGA, ACA, ATT, TAA]
+Is Protein?: YES
+
+Region Name: sodium/proton antiporter 1
+Nucleotides: GTGAAACATCTGCATCGATTCTTTAGCAGTGATGCCTCGGGAGGCATTATTCTCATTATTGCCGCTGTATTAGCGATGATTATGGCCAACAGCGGTGCAACCAGTGGATGGTATCACGACTTTCTTGAGACGCCGGTTCAGCTCCGGGTTGGGACACTTGAGATCAACAAGAACATGCTGCTATGGATCAATGACGCTCTGATGGCGGTATTTTTCCTGTTGGTTGGTCTGGAAGTTAAACGCGAGCTGATGCAAGGTTCGCTGGCCAGTCTGCGCCAGGCGGCATTTCCTGTTATTGCCGCAATCGGCGGGATGATTGTCCCGGCATTGCTCTATCTGGCTTTTAACTATGCCGATCCGATTACCCGCGAAGGCTGGGCAATCCCGGCGGCGACTGACATTGCCTTTGCACTTGGTGTGTTGGCGCTGTTGGGAAGTCGTGTTCCGTTAGCGCTGAAGATCTTTTTGATGGCTCTGGCTATTATCGACGATCTTGGGGCCATCATTATCATCGCATTGTTCTACACTAATGACTTATCGATGGCCTCTCTTGGCGTCGCGGCTGTAGCAATTGCGGTACTCGCGGTATTGAATCTGTGTGGTGTACGCCGCACGGGCGTTTATATTCTGGTTGGCGTGGTGCTGTGGACAGCGGTGTTGAAATCGGGGGTTCACGCAACCCTGGCTGGCGTCATTGTCGGCTTCTTTATTCCTTTGAAAGAGAAGCATGGGCGCTCTCCGGCTAAACGTCTGGAGCATGTTTTGCATCCATGGGTGGCGTATCTGATTTTGCCGCTGTTTGCATTTGCTAATGCTGGCGTTTCACTGCAAGGTGTCACGCTGGAAGGTTTGACCTCCATTCTGCCATTAGGGATCATCGCTGGTTTGCTGATTGGCAAGCCACTGGGTATTAGTCTGTTCTGCTGGTTGGCGCTGCGTTTGAAATTGGCACATCTGCCAGAGGGAACGACTTACCAGCAAATTATGGCGGTTGGTATCCTGTGCGGTATCGGTTTTACTATGTCTATCTTTATTGCCAGCCTGGCATTTGGTAGCGTAGATCCAGAACTGATTAACTGGGCAAAATTAGGTATCCTTGTCGGTTCAATTTCTTCGGCGGTAATTGGATATAGCTGGTTACGCGTTCGTTTACGTCCATCAGTTTGA
+Nuc. Counts: [215, 258, 331, 363]
+Total Mass%: [19.0, 18.7, 32.7, 29.7] of 153154.3
+Codons List: [GTG, AAA, CAT, CTG, CAT, CGA, TTC, TTT, AGC, AGT, GAT, GCC, TCG, GGA, GGC, ATT, ATT, CTC, ATT, ATT, GCC, GCT, GTA, TTA, GCG, ATG, ATT, ATG, GCC, AAC, AGC, GGT, GCA, ACC, AGT, GGA, TGG, TAT, CAC, GAC, TTT, CTT, GAG, ACG, CCG, GTT, CAG, CTC, CGG, GTT, GGG, ACA, CTT, GAG, ATC, AAC, AAG, AAC, ATG, CTG, CTA, TGG, ATC, AAT, GAC, GCT, CTG, ATG, GCG, GTA, TTT, TTC, CTG, TTG, GTT, GGT, CTG, GAA, GTT, AAA, CGC, GAG, CTG, ATG, CAA, GGT, TCG, CTG, GCC, AGT, CTG, CGC, CAG, GCG, GCA, TTT, CCT, GTT, ATT, GCC, GCA, ATC, GGC, GGG, ATG, ATT, GTC, CCG, GCA, TTG, CTC, TAT, CTG, GCT, TTT, AAC, TAT, GCC, GAT, CCG, ATT, ACC, CGC, GAA, GGC, TGG, GCA, ATC, CCG, GCG, GCG, ACT, GAC, ATT, GCC, TTT, GCA, CTT, GGT, GTG, TTG, GCG, CTG, TTG, GGA, AGT, CGT, GTT, CCG, TTA, GCG, CTG, AAG, ATC, TTT, TTG, ATG, GCT, CTG, GCT, ATT, ATC, GAC, GAT, CTT, GGG, GCC, ATC, ATT, ATC, ATC, GCA, TTG, TTC, TAC, ACT, AAT, GAC, TTA, TCG, ATG, GCC, TCT, CTT, GGC, GTC, GCG, GCT, GTA, GCA, ATT, GCG, GTA, CTC, GCG, GTA, TTG, AAT, CTG, TGT, GGT, GTA, CGC, CGC, ACG, GGC, GTT, TAT, ATT, CTG, GTT, GGC, GTG, GTG, CTG, TGG, ACA, GCG, GTG, TTG, AAA, TCG, GGG, GTT, CAC, GCA, ACC, CTG, GCT, GGC, GTC, ATT, GTC, GGC, TTC, TTT, ATT, CCT, TTG, AAA, GAG, AAG, CAT, GGG, CGC, TCT, CCG, GCT, AAA, CGT, CTG, GAG, CAT, GTT, TTG, CAT, CCA, TGG, GTG, GCG, TAT, CTG, ATT, TTG, CCG, CTG, TTT, GCA, TTT, GCT, AAT, GCT, GGC, GTT, TCA, CTG, CAA, GGT, GTC, ACG, CTG, GAA, GGT, TTG, ACC, TCC, ATT, CTG, CCA, TTA, GGG, ATC, ATC, GCT, GGT, TTG, CTG, ATT, GGC, AAG, CCA, CTG, GGT, ATT, AGT, CTG, TTC, TGC, TGG, TTG, GCG, CTG, CGT, TTG, AAA, TTG, GCA, CAT, CTG, CCA, GAG, GGA, ACG, ACT, TAC, CAG, CAA, ATT, ATG, GCG, GTT, GGT, ATC, CTG, TGC, GGT, ATC, GGT, TTT, ACT, ATG, TCT, ATC, TTT, ATT, GCC, AGC, CTG, GCA, TTT, GGT, AGC, GTA, GAT, CCA, GAA, CTG, ATT, AAC, TGG, GCA, AAA, TTA, GGT, ATC, CTT, GTC, GGT, TCA, ATT, TCT, TCG, GCG, GTA, ATT, GGA, TAT, AGC, TGG, TTA, CGC, GTT, CGT, TTA, CGT, CCA, TCA, GTT, TGA]
+Is Protein?: NO
+
+Region Name: transcriptional activator protein NhaR
+Nucleotides: ATGAGCATGTCTCATATCAATTACAACCACTTGTATTACTTCTGGCATGTCTACAAAGAAGGTTCTGTGGTTGGCGCAGCGGAGGCGCTTTATTTAACACCACAAACCATTACCGGGCAGATCCGGGCGCTGGAAGAGCGCCTGCAAGGGAAACTATTTAAGCGTAAAGGACGTGGTCTGGAACCCAGCGAACTGGGGGAACTGGTCTATCGCTATGCCGATAAAATGTTCACCTTAAGCCAGGAAATGCTGGATATCGTCAACTATCGCAAAGAGTCCAACTTATTGTTTGATGTTGGTGTGGCAGATGCACTTTCCAAACGTCTGGTCAGCAGTGTTCTGGATGCCGCAGTTGTGGAAGACGAGCAGATCCATCTACGCTGTTTCGAATCGACGCACGAGATGCTTTTAGAGCAGTTGAGTCAGCATAAACTGGATATGATCATCTCTGACTGTCCGATCGATTCCACTCAGCAGGAAGGGCTGTTTTCCATGAAAATTGGCGAATGTGGTGTCAGTTTCTGGTGCACTAACCCACTACCAGAAAAGCCGTTTCCTGCCTGTCTTGAAGAGCGTCGTTTACTTATTCCGGGGCGTCGCTCAATGTTGGGGCGTAAACTATTAAACTGGTTTAACTCCCAGGGCTTGAACGTCGAAATTTTGGGTGAGTTTGATGATGCTGCGTTGATGAAAGCCTTTGGGGCGACGCATAACGCTATTTTCGTTGCACCTTCGCTTTACGCTAATGATTTCTATAACGATGACTCGGTTGTGGAGATAGGCCGTGTTGAGAACGTGATGGAAGAGTACCACGCGATTTTTGCCGAAAGGATGATTCAGCACCCTGCAGTACAGCGTATCTGCAATACAGACTATTCTGCGCTGTTTACTCCAGCTTCAAAATAA
+Nuc. Counts: [228, 197, 232, 249]
+Total Mass%: [25.9, 18.4, 29.5, 26.2] of 118909.8
+Codons List: [ATG, AGC, ATG, TCT, CAT, ATC, AAT, TAC, AAC, CAC, TTG, TAT, TAC, TTC, TGG, CAT, GTC, TAC, AAA, GAA, GGT, TCT, GTG, GTT, GGC, GCA, GCG, GAG, GCG, CTT, TAT, TTA, ACA, CCA, CAA, ACC, ATT, ACC, GGG, CAG, ATC, CGG, GCG, CTG, GAA, GAG, CGC, CTG, CAA, GGG, AAA, CTA, TTT, AAG, CGT, AAA, GGA, CGT, GGT, CTG, GAA, CCC, AGC, GAA, CTG, GGG, GAA, CTG, GTC, TAT, CGC, TAT, GCC, GAT, AAA, ATG, TTC, ACC, TTA, AGC, CAG, GAA, ATG, CTG, GAT, ATC, GTC, AAC, TAT, CGC, AAA, GAG, TCC, AAC, TTA, TTG, TTT, GAT, GTT, GGT, GTG, GCA, GAT, GCA, CTT, TCC, AAA, CGT, CTG, GTC, AGC, AGT, GTT, CTG, GAT, GCC, GCA, GTT, GTG, GAA, GAC, GAG, CAG, ATC, CAT, CTA, CGC, TGT, TTC, GAA, TCG, ACG, CAC, GAG, ATG, CTT, TTA, GAG, CAG, TTG, AGT, CAG, CAT, AAA, CTG, GAT, ATG, ATC, ATC, TCT, GAC, TGT, CCG, ATC, GAT, TCC, ACT, CAG, CAG, GAA, GGG, CTG, TTT, TCC, ATG, AAA, ATT, GGC, GAA, TGT, GGT, GTC, AGT, TTC, TGG, TGC, ACT, AAC, CCA, CTA, CCA, GAA, AAG, CCG, TTT, CCT, GCC, TGT, CTT, GAA, GAG, CGT, CGT, TTA, CTT, ATT, CCG, GGG, CGT, CGC, TCA, ATG, TTG, GGG, CGT, AAA, CTA, TTA, AAC, TGG, TTT, AAC, TCC, CAG, GGC, TTG, AAC, GTC, GAA, ATT, TTG, GGT, GAG, TTT, GAT, GAT, GCT, GCG, TTG, ATG, AAA, GCC, TTT, GGG, GCG, ACG, CAT, AAC, GCT, ATT, TTC, GTT, GCA, CCT, TCG, CTT, TAC, GCT, AAT, GAT, TTC, TAT, AAC, GAT, GAC, TCG, GTT, GTG, GAG, ATA, GGC, CGT, GTT, GAG, AAC, GTG, ATG, GAA, GAG, TAC, CAC, GCG, ATT, TTT, GCC, GAA, AGG, ATG, ATT, CAG, CAC, CCT, GCA, GTA, CAG, CGT, ATC, TGC, AAT, ACA, GAC, TAT, TCT, GCG, CTG, TTT, ACT, CCA, GCT, TCA, AAA, TAA]
+Is Protein?: YES
+
+Region Name: riboflavin kinase
+Nucleotides: ATGAAGCTGATACGCGGCATACATAATCTCAGCCAGGCCCCGCAAGAAGGGTGTGTGCTGACTATTGGTAATTTCGACGGCGTGCATCGCGGTCATCGCGCGCTGTTACAGGGCTTGCAGGAAGAAGGGCGCAAGCGCAACTTACCGGTGATGGTGATGCTTTTTGAACCTCAACCACTGGAACTGTTTGCTACTGATAAAGCCCCGGCACGGCTCACCCGGCTGCGGGAAAAACTGCGTTATCTTGCAGAGTGTGGCGTTGATTACGTGCTGTGCGTGCGTTTTGACAGGCGTTTTGCGGCGTTAACCGCGCAAAACTTCATCAGTGATCTTCTGGTGAAGCACTTGCGGGTAAAATTTCTTGCCGTAGGTGACGATTTCCGCTTTGGCGCTGGTCGTGAAGGCGATTTCTTGTTATTACAGAAAGCGGGCATGGAATACGGCTTCGATATCACCAGCACGCAAACTTTTTGCGAAGGTGGTGTGCGTATCAGCAGCACCGCCGTGCGTCAGGCGCTTGCGGATGACAATCTGGCTCTGGCAGAAAGTTTACTGGGGCACCCGTTTGCTATCTCCGGGCGTGTAGTCCACGGTGATGAATTAGGGCGCACTATAGGTTTCCCGACGGCGAATGTACCGCTACGCCGTCAGGTTTCCCCGGTGAAAGGGGTTTATGCGGTAGAAGTGTTGGGCCTTGGCGAAAAGCCGTTACCCGGCGTTGCAAACATCGGAACACGCCCAACGGTTGCCGGTATTCGCCAGCAACTGGAAGTGCATTTGTTAGATGTTGCAATGGACCTTTATGGTCGCCATATACAAGTAGTGCTGCGTAAAAAAATACGCAATGAGCAGCGATTTGCATCGCTGGACGAACTGAAAGCGCAGATTGCGCGTGATGAATTAACCGCCCGCGAATTTTTTGGGCTAACAAAACCGGCTTAA
+Nuc. Counts: [213, 221, 276, 232]
+Total Mass%: [23.2, 19.8, 33.6, 23.4] of 124072.2
+Codons List: [ATG, AAG, CTG, ATA, CGC, GGC, ATA, CAT, AAT, CTC, AGC, CAG, GCC, CCG, CAA, GAA, GGG, TGT, GTG, CTG, ACT, ATT, GGT, AAT, TTC, GAC, GGC, GTG, CAT, CGC, GGT, CAT, CGC, GCG, CTG, TTA, CAG, GGC, TTG, CAG, GAA, GAA, GGG, CGC, AAG, CGC, AAC, TTA, CCG, GTG, ATG, GTG, ATG, CTT, TTT, GAA, CCT, CAA, CCA, CTG, GAA, CTG, TTT, GCT, ACT, GAT, AAA, GCC, CCG, GCA, CGG, CTC, ACC, CGG, CTG, CGG, GAA, AAA, CTG, CGT, TAT, CTT, GCA, GAG, TGT, GGC, GTT, GAT, TAC, GTG, CTG, TGC, GTG, CGT, TTT, GAC, AGG, CGT, TTT, GCG, GCG, TTA, ACC, GCG, CAA, AAC, TTC, ATC, AGT, GAT, CTT, CTG, GTG, AAG, CAC, TTG, CGG, GTA, AAA, TTT, CTT, GCC, GTA, GGT, GAC, GAT, TTC, CGC, TTT, GGC, GCT, GGT, CGT, GAA, GGC, GAT, TTC, TTG, TTA, TTA, CAG, AAA, GCG, GGC, ATG, GAA, TAC, GGC, TTC, GAT, ATC, ACC, AGC, ACG, CAA, ACT, TTT, TGC, GAA, GGT, GGT, GTG, CGT, ATC, AGC, AGC, ACC, GCC, GTG, CGT, CAG, GCG, CTT, GCG, GAT, GAC, AAT, CTG, GCT, CTG, GCA, GAA, AGT, TTA, CTG, GGG, CAC, CCG, TTT, GCT, ATC, TCC, GGG, CGT, GTA, GTC, CAC, GGT, GAT, GAA, TTA, GGG, CGC, ACT, ATA, GGT, TTC, CCG, ACG, GCG, AAT, GTA, CCG, CTA, CGC, CGT, CAG, GTT, TCC, CCG, GTG, AAA, GGG, GTT, TAT, GCG, GTA, GAA, GTG, TTG, GGC, CTT, GGC, GAA, AAG, CCG, TTA, CCC, GGC, GTT, GCA, AAC, ATC, GGA, ACA, CGC, CCA, ACG, GTT, GCC, GGT, ATT, CGC, CAG, CAA, CTG, GAA, GTG, CAT, TTG, TTA, GAT, GTT, GCA, ATG, GAC, CTT, TAT, GGT, CGC, CAT, ATA, CAA, GTA, GTG, CTG, CGT, AAA, AAA, ATA, CGC, AAT, GAG, CAG, CGA, TTT, GCA, TCG, CTG, GAC, GAA, CTG, AAA, GCG, CAG, ATT, GCG, CGT, GAT, GAA, TTA, ACC, GCC, CGC, GAA, TTT, TTT, GGG, CTA, ACA, AAA, CCG, GCT, TAA]
+Is Protein?: YES
+
+Region Name: Isoleucyl-tRNA synthetase
+Nucleotides: ATGAGTGACTATAAATCAACCCTGAATTTGCCGGAAACAGGGTTCCCGATGCGTGGCGATCTCGCCAAGCGCGAACCGGGAATGCTGGCGCGTTGGACTGATGATGATCTGTACGGCATCATCCGTGCGGCTAAAAAAGGCAAAAAAACCTTCATTCTGCATGATGGCCCTCCTTATGCGAATGGCAGCATTCATATTGGTCACTCGGTTAACAAGATTCTGAAAGACATTATCATTAAGTCCAAAGGGCTTTCTGGATATGACTCGCCGTATGTGCCTGGCTGGGACTGTCATGGTCTGCCAATCGAACTGAAAGTAGAGCAAGAATACGGTAAGCCGGGGGAGAAATTCACCGCCGCTGAGTTCCGCGCCAAGTGCCGCGAATACGCTGCGACCCAGGTTGACGGTCAGCGCAAAGACTTTATCCGTCTGGGCGTGCTGGGCGACTGGTCGCACCCGTACCTGACCATGGACTTCAAAACTGAAGCCAACATCATCCGCGCGCTGGGCAAAATCATCGGCAACGGTCACCTGCACAAAGGCGCGAAGCCGGTGCACTGGTGCGTTGACTGCCGTTCTGCACTGGCAGAAGCGGAAGTTGAGTATTACGACAAAACTTCTCCGTCCATCGACGTCGCTTTCCAGGCGGTCGATCAGGATGCGCTGAAAACGAAATTTGGCGTAAGCAATGTTAACGGCCCAATTTCGCTGGTTATCTGGACCACCACGCCGTGGACGCTGCCTGCTAACCGCGCAATCTCCATTGCACCTGATTTTGATTATGCGCTGGTGCAAATCGACGGTCAGGCCGTGATCCTCGCGAAAGATCTGGTTGAAAGCGTAATGCAGCGTATCGGCGTTAGCGATTACACCATTCTTGGCACGGTGAAAGGTGCCGAGCTGGAACTGTTGCGCTTTACCCATCCGTTTATGGACTTCGATGTTCCGGCAATTCTCGGCGACCACGTTACGCTGGATGCCGGTACCGGTGCCGTTCATACCGCGCCAGGCCACGGTCCGGACGACTATGTGATCGGTCAAAAATATGGTCTGGAAACCGCTAACCCGGTTGGCCCGGACGGCACTTATCTGCCGGGTACTTACCCGACTCTGGATGGCGTTAACGTCTTCAAAGCGAACGATATTGTCATTGCGTTGTTGCAGGAAAAAGGCGCACTGTTGCACGTTGAGAAAATGCAACACAGCTATCCGTGCTGCTGGCGTCATAAAACGCCGATCATCTTCCGCGCGACGCCGCAGTGGTTCGTCAGCATGGATCAGAAAGGTCTGCGTGCGCAGTCACTGAAAGAGATCAAAGGCGTGCAGTGGATCCCTGACTGGGGCCAGGCGCGTATCGAGTCGATGGTTGCTAACCGTCCTGACTGGTGTATCTCTCGTCAGCGTACCTGGGGCGTGCCGATGTCACTGTTCGTGCACAAAGACACAGAAGAACTGCATCCGCGTACTCTCGAACTGATGGAAGAAGTGGCAAAACGCGTTGAAGTTGACGGCATTCAGGCGTGGTGGGATCTCGATGCGAAAGAGATCCTCGGCGACGAAGCTGACCAGTATGTGAAAGTACCGGATACGCTGGATGTATGGTTTGACTCCGGATCTACCCACTCTTCCGTTGTTGATGTGCGTCCGGAATTTGCCGGTCACGCAGCGGACATGTATCTGGAAGGTTCTGACCAACACCGTGGCTGGTTCATGTCTTCCCTGATGATCTCTACCGCGATGAAGGGCAAAGCGCCATATCGTCAGGTACTGACTCACGGCTTTACCGTGGATGGTCAGGGTCGCAAGATGTCTAAATCCATCGGTAACACCGTTTCGCCGCAGGATGTGATGAATAAACTGGGTGCGGATATTCTGCGTCTGTGGGTGGCATCAACCGACTACACTGGCGAAATGGCCGTTTCTGACGAGATCCTGAAACGTGCTGCCGACAGCTATCGTCGTATCCGTAACACCGCGCGCTTCCTGCTGGCAAACCTGAACGGTTTTGATCCGGCAAAAGATATGGTGAAACCGGAAGAGATGGTGGTACTGGATCGCTGGGCCGTAGGTTGTGCGAAAGCGGCACAGGAAGACATCCTCAAGGCGTACGAAGCATACGATTTCCACGAAGTGGTACAGCGTCTGATGCGCTTCTGCTCCGTTGAGATGGGTTCCTTCTACCTCGACATCATCAAAGACCGTCAGTATACCGCCAAAGCGGACAGCGTGGCGCGTCGTAGCTGCCAGACTGCGCTGTATCACATCGCAGAAGCGCTGGTTCGCTGGATGGCACCAATCCTCTCCTTCACCGCTGATGAAGTGTGGGGTTACCTGCCGGGCGAACGTGAAAAATACGTCTTCACCGGCGAGTGGTACGAAGGCCTGTTTGGTCTGGCAGACAGTGAAGCAATGAACGATGCGTTCTGGGACGAGCTGTTGAAAGTGCGTGGCGAAGTGAACAAAGTCATTGAGCAAGCGCGTGCCGATAAGAACGTGGGCGGCTCGCTGGAAGCGGCAGTAACCTTGTATGCAGAACCGGAACTGGCGGCGAAACTGACCGCGCTGGGCGATGAATTACGATTTGTCCTGTTGACCTCCGGCGCTACCGTTGCAGACTATAACGACGCACCTGCTGATGCCCAGCAGAGCGAAGTCCTCAAAGGGCTGAAAGTCGCGTTGAGTAAAGCCGAAGGTGAGAAGTGTCCTCGCTGCTGGCACTACACCCAGGATGTCGGCAAGGTGGCGGAACACGCAGAAATCTGCGGCCGCTGTGTCAGCAACGTCGCCGGTGACGGTGAAAAACGTAAGTTTGCCTGA
+Nuc. Counts: [660, 720, 817, 620]
+Total Mass%: [24.1, 21.6, 33.4, 21.0] of 370216.6
+Codons List: [ATG, AGT, GAC, TAT, AAA, TCA, ACC, CTG, AAT, TTG, CCG, GAA, ACA, GGG, TTC, CCG, ATG, CGT, GGC, GAT, CTC, GCC, AAG, CGC, GAA, CCG, GGA, ATG, CTG, GCG, CGT, TGG, ACT, GAT, GAT, GAT, CTG, TAC, GGC, ATC, ATC, CGT, GCG, GCT, AAA, AAA, GGC, AAA, AAA, ACC, TTC, ATT, CTG, CAT, GAT, GGC, CCT, CCT, TAT, GCG, AAT, GGC, AGC, ATT, CAT, ATT, GGT, CAC, TCG, GTT, AAC, AAG, ATT, CTG, AAA, GAC, ATT, ATC, ATT, AAG, TCC, AAA, GGG, CTT, TCT, GGA, TAT, GAC, TCG, CCG, TAT, GTG, CCT, GGC, TGG, GAC, TGT, CAT, GGT, CTG, CCA, ATC, GAA, CTG, AAA, GTA, GAG, CAA, GAA, TAC, GGT, AAG, CCG, GGG, GAG, AAA, TTC, ACC, GCC, GCT, GAG, TTC, CGC, GCC, AAG, TGC, CGC, GAA, TAC, GCT, GCG, ACC, CAG, GTT, GAC, GGT, CAG, CGC, AAA, GAC, TTT, ATC, CGT, CTG, GGC, GTG, CTG, GGC, GAC, TGG, TCG, CAC, CCG, TAC, CTG, ACC, ATG, GAC, TTC, AAA, ACT, GAA, GCC, AAC, ATC, ATC, CGC, GCG, CTG, GGC, AAA, ATC, ATC, GGC, AAC, GGT, CAC, CTG, CAC, AAA, GGC, GCG, AAG, CCG, GTG, CAC, TGG, TGC, GTT, GAC, TGC, CGT, TCT, GCA, CTG, GCA, GAA, GCG, GAA, GTT, GAG, TAT, TAC, GAC, AAA, ACT, TCT, CCG, TCC, ATC, GAC, GTC, GCT, TTC, CAG, GCG, GTC, GAT, CAG, GAT, GCG, CTG, AAA, ACG, AAA, TTT, GGC, GTA, AGC, AAT, GTT, AAC, GGC, CCA, ATT, TCG, CTG, GTT, ATC, TGG, ACC, ACC, ACG, CCG, TGG, ACG, CTG, CCT, GCT, AAC, CGC, GCA, ATC, TCC, ATT, GCA, CCT, GAT, TTT, GAT, TAT, GCG, CTG, GTG, CAA, ATC, GAC, GGT, CAG, GCC, GTG, ATC, CTC, GCG, AAA, GAT, CTG, GTT, GAA, AGC, GTA, ATG, CAG, CGT, ATC, GGC, GTT, AGC, GAT, TAC, ACC, ATT, CTT, GGC, ACG, GTG, AAA, GGT, GCC, GAG, CTG, GAA, CTG, TTG, CGC, TTT, ACC, CAT, CCG, TTT, ATG, GAC, TTC, GAT, GTT, CCG, GCA, ATT, CTC, GGC, GAC, CAC, GTT, ACG, CTG, GAT, GCC, GGT, ACC, GGT, GCC, GTT, CAT, ACC, GCG, CCA, GGC, CAC, GGT, CCG, GAC, GAC, TAT, GTG, ATC, GGT, CAA, AAA, TAT, GGT, CTG, GAA, ACC, GCT, AAC, CCG, GTT, GGC, CCG, GAC, GGC, ACT, TAT, CTG, CCG, GGT, ACT, TAC, CCG, ACT, CTG, GAT, GGC, GTT, AAC, GTC, TTC, AAA, GCG, AAC, GAT, ATT, GTC, ATT, GCG, TTG, TTG, CAG, GAA, AAA, GGC, GCA, CTG, TTG, CAC, GTT, GAG, AAA, ATG, CAA, CAC, AGC, TAT, CCG, TGC, TGC, TGG, CGT, CAT, AAA, ACG, CCG, ATC, ATC, TTC, CGC, GCG, ACG, CCG, CAG, TGG, TTC, GTC, AGC, ATG, GAT, CAG, AAA, GGT, CTG, CGT, GCG, CAG, TCA, CTG, AAA, GAG, ATC, AAA, GGC, GTG, CAG, TGG, ATC, CCT, GAC, TGG, GGC, CAG, GCG, CGT, ATC, GAG, TCG, ATG, GTT, GCT, AAC, CGT, CCT, GAC, TGG, TGT, ATC, TCT, CGT, CAG, CGT, ACC, TGG, GGC, GTG, CCG, ATG, TCA, CTG, TTC, GTG, CAC, AAA, GAC, ACA, GAA, GAA, CTG, CAT, CCG, CGT, ACT, CTC, GAA, CTG, ATG, GAA, GAA, GTG, GCA, AAA, CGC, GTT, GAA, GTT, GAC, GGC, ATT, CAG, GCG, TGG, TGG, GAT, CTC, GAT, GCG, AAA, GAG, ATC, CTC, GGC, GAC, GAA, GCT, GAC, CAG, TAT, GTG, AAA, GTA, CCG, GAT, ACG, CTG, GAT, GTA, TGG, TTT, GAC, TCC, GGA, TCT, ACC, CAC, TCT, TCC, GTT, GTT, GAT, GTG, CGT, CCG, GAA, TTT, GCC, GGT, CAC, GCA, GCG, GAC, ATG, TAT, CTG, GAA, GGT, TCT, GAC, CAA, CAC, CGT, GGC, TGG, TTC, ATG, TCT, TCC, CTG, ATG, ATC, TCT, ACC, GCG, ATG, AAG, GGC, AAA, GCG, CCA, TAT, CGT, CAG, GTA, CTG, ACT, CAC, GGC, TTT, ACC, GTG, GAT, GGT, CAG, GGT, CGC, AAG, ATG, TCT, AAA, TCC, ATC, GGT, AAC, ACC, GTT, TCG, CCG, CAG, GAT, GTG, ATG, AAT, AAA, CTG, GGT, GCG, GAT, ATT, CTG, CGT, CTG, TGG, GTG, GCA, TCA, ACC, GAC, TAC, ACT, GGC, GAA, ATG, GCC, GTT, TCT, GAC, GAG, ATC, CTG, AAA, CGT, GCT, GCC, GAC, AGC, TAT, CGT, CGT, ATC, CGT, AAC, ACC, GCG, CGC, TTC, CTG, CTG, GCA, AAC, CTG, AAC, GGT, TTT, GAT, CCG, GCA, AAA, GAT, ATG, GTG, AAA, CCG, GAA, GAG, ATG, GTG, GTA, CTG, GAT, CGC, TGG, GCC, GTA, GGT, TGT, GCG, AAA, GCG, GCA, CAG, GAA, GAC, ATC, CTC, AAG, GCG, TAC, GAA, GCA, TAC, GAT, TTC, CAC, GAA, GTG, GTA, CAG, CGT, CTG, ATG, CGC, TTC, TGC, TCC, GTT, GAG, ATG, GGT, TCC, TTC, TAC, CTC, GAC, ATC, ATC, AAA, GAC, CGT, CAG, TAT, ACC, GCC, AAA, GCG, GAC, AGC, GTG, GCG, CGT, CGT, AGC, TGC, CAG, ACT, GCG, CTG, TAT, CAC, ATC, GCA, GAA, GCG, CTG, GTT, CGC, TGG, ATG, GCA, CCA, ATC, CTC, TCC, TTC, ACC, GCT, GAT, GAA, GTG, TGG, GGT, TAC, CTG, CCG, GGC, GAA, CGT, GAA, AAA, TAC, GTC, TTC, ACC, GGC, GAG, TGG, TAC, GAA, GGC, CTG, TTT, GGT, CTG, GCA, GAC, AGT, GAA, GCA, ATG, AAC, GAT, GCG, TTC, TGG, GAC, GAG, CTG, TTG, AAA, GTG, CGT, GGC, GAA, GTG, AAC, AAA, GTC, ATT, GAG, CAA, GCG, CGT, GCC, GAT, AAG, AAC, GTG, GGC, GGC, TCG, CTG, GAA, GCG, GCA, GTA, ACC, TTG, TAT, GCA, GAA, CCG, GAA, CTG, GCG, GCG, AAA, CTG, ACC, GCG, CTG, GGC, GAT, GAA, TTA, CGA, TTT, GTC, CTG, TTG, ACC, TCC, GGC, GCT, ACC, GTT, GCA, GAC, TAT, AAC, GAC, GCA, CCT, GCT, GAT, GCC, CAG, CAG, AGC, GAA, GTC, CTC, AAA, GGG, CTG, AAA, GTC, GCG, TTG, AGT, AAA, GCC, GAA, GGT, GAG, AAG, TGT, CCT, CGC, TGC, TGG, CAC, TAC, ACC, CAG, GAT, GTC, GGC, AAG, GTG, GCG, GAA, CAC, GCA, GAA, ATC, TGC, GGC, CGC, TGT, GTC, AGC, AAC, GTC, GCC, GGT, GAC, GGT, GAA, AAA, CGT, AAG, TTT, GCC, TGA]
+Is Protein?: YES
+
+Region Name: Non-protein region
+Nucleotides: GCTTGCGCCAACGCCATTTCATCGCCATCCCGCCGAGCATACAGGCCTCGGAAGAACCAATGGTGTTGGTGCCAACGGCCTGACCATTTTTCGGTGCAGGCGCATGCCACAGATCGGCAACCATGTTTACGCAACGCAGATCGATTGCTGCAGATTGCGGATATTCTTCTTTGTCGATCCAGTTTTTGTTAATGGATAAATCCA
+Nuc. Counts: [46, 56, 49, 53]
+Total Mass%: [23.5, 23.5, 28.0, 25.0] of 26473.6
+Codons List: [GCT, TGC, GCC, AAC, GCC, ATT, TCA, TCG, CCA, TCC, CGC, CGA, GCA, TAC, AGG, CCT, CGG, AAG, AAC, CAA, TGG, TGT, TGG, TGC, CAA, CGG, CCT, GAC, CAT, TTT, TCG, GTG, CAG, GCG, CAT, GCC, ACA, GAT, CGG, CAA, CCA, TGT, TTA, CGC, AAC, GCA, GAT, CGA, TTG, CTG, CAG, ATT, GCG, GAT, ATT, CTT, CTT, TGT, CGA, TCC, AGT, TTT, TGT, TAA, TGG, ATA, AAT, CCA]
+Is Protein?: NO
+
+Region Name: FKBP-type 16 kDa peptidyl-prolyl cis-trans isomerase
+Nucleotides: ATGTCTGAATCTGTACAGAGCAATAGCGCCGTCCTGGTGCACTTCACGCTAAAACTCGACGATGGCACCACCGCTGAGTCTACCCGCAACAACGGTAAACCGGCGCTGTTCCGCCTGGGTGATGCTTCTCTTTCTGAAGGGCTGGAGCAACACCTGCTGGGGCTGAAAGTGGGCGATAAAACCACCTTCTCGCTGGAGCCAGATGCGGCGTTTGGCGTGCCGTCACCGGACCTGATTCAGTACTTCTCCCGCCGTGAATTTATGGATGCAGGCGAGCCAGAAATTGGCGCAATCATGCTTTTTACCGCAATGGATGGCAGTGAGATGCCTGGCGTGATCCGCGAAATTAACGGCGACTCCATTACCGTTGATTTCAACCATCCGCTGGCCGGGCAGACCGTTCATTTTGATATTGAAGTGCTGGAAATCGATCCGGCACTGGAGGCGTAA
+Nuc. Counts: [100, 121, 125, 104]
+Total Mass%: [23.0, 22.8, 32.1, 22.1] of 58858.4
+Codons List: [ATG, TCT, GAA, TCT, GTA, CAG, AGC, AAT, AGC, GCC, GTC, CTG, GTG, CAC, TTC, ACG, CTA, AAA, CTC, GAC, GAT, GGC, ACC, ACC, GCT, GAG, TCT, ACC, CGC, AAC, AAC, GGT, AAA, CCG, GCG, CTG, TTC, CGC, CTG, GGT, GAT, GCT, TCT, CTT, TCT, GAA, GGG, CTG, GAG, CAA, CAC, CTG, CTG, GGG, CTG, AAA, GTG, GGC, GAT, AAA, ACC, ACC, TTC, TCG, CTG, GAG, CCA, GAT, GCG, GCG, TTT, GGC, GTG, CCG, TCA, CCG, GAC, CTG, ATT, CAG, TAC, TTC, TCC, CGC, CGT, GAA, TTT, ATG, GAT, GCA, GGC, GAG, CCA, GAA, ATT, GGC, GCA, ATC, ATG, CTT, TTT, ACC, GCA, ATG, GAT, GGC, AGT, GAG, ATG, CCT, GGC, GTG, ATC, CGC, GAA, ATT, AAC, GGC, GAC, TCC, ATT, ACC, GTT, GAT, TTC, AAC, CAT, CCG, CTG, GCC, GGG, CAG, ACC, GTT, CAT, TTT, GAT, ATT, GAA, GTG, CTG, GAA, ATC, GAT, CCG, GCA, CTG, GAG, GCG, TAA]
+Is Protein?: YES
+

src/main/java/com/matthewjensen/project/modules/grammer/GrammarMain.java

@@ -0,0 +1,63 @@
+// Stuart Reges
+// 3/10/04
+//
+// GrammarMain contains a main program that prompts a user for the name of a
+// grammar file and then gives the user the opportunity to generate random
+// versions of various elements of the grammar.
+
+import java.io.*;
+import java.util.*;
+
+public class GrammarMain {
+    public static void main(String[] args) throws FileNotFoundException {
+        Scanner console = new Scanner(System.in);
+        System.out.println("Welcome to the cs145 random sentence generator.");
+        System.out.println();
+
+        // open grammar file
+        System.out.print("What is the name of the grammar file? ");
+        String fileName = console.nextLine();
+        Scanner input = new Scanner(new File(fileName));
+
+        // read the grammar file and construct the grammar solver
+        List<String> grammar = new ArrayList<String>();
+        while (input.hasNextLine())
+            grammar.add(input.nextLine());
+        GrammarSolver solver = 
+            new GrammarSolver(Collections.unmodifiableList(grammar));
+
+        showResults(console, solver);
+    }
+
+    // pre : console open for console reading, solver initialized
+    // post: allows the user to repeatedly pick a grammar element to generate
+    public static void showResults(Scanner console, GrammarSolver solver) {
+        for(;;) {
+            System.out.println();
+            System.out.println("Available symbols to generate are:");
+            System.out.println(solver.getSymbols());
+            System.out.print("What do you want generated (return to quit)? ");
+            String target = console.nextLine();
+            if (target.length() == 0)
+                break;
+            if (!solver.grammarContains(target))
+                System.out.println("Illegal symbol");
+            else {
+                System.out.print("How many do you want me to generate? ");
+                if (!console.hasNextInt())
+                    System.out.println("that's not an integer");
+                else {
+                    int number = console.nextInt();
+                    if (number < 0)
+                        System.out.println("no negatives allowed");
+                    else {
+                        String[] answers = solver.generate(target, number);
+                        for (int i = 0; i < number; i++)
+                            System.out.println(answers[i]);
+                    }
+                }
+                console.nextLine();  // to position to next line
+            }
+        }
+    }
+}

src/main/java/com/matthewjensen/project/modules/grammer/GrammarSolver.java

@@ -0,0 +1,158 @@
+/**
+*
+* Matt Jensen
+* CS145 - Lab 5
+* 5/30/19
+*
+*/
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class GrammarSolver {
+
+    private Map<String, List<String>> grammarMap;
+    private List<String> grammarList;
+
+    // sets grammar of object.
+    public GrammarSolver(List<String> grammarList) {
+        this.grammarList = grammarList;
+        this.grammarMap = new TreeMap<String, List<String>>();
+
+        // add all lines to grammer.
+        for(String entry : grammarList) {
+            if( this.isValidEntry(entry) ) { // throws exception if illegal.
+                this.addEntry(entry);
+            } 
+        }
+    }
+
+    /**
+    *
+    * Public Methods
+    *
+    */
+
+    // publicly evaluate grammar
+    public String[] generate(String symbol, int times) {
+        String[] result = new String[times];
+        for( int i = 0; i < result.length; i++) {
+            result[i] = this.generate(symbol);
+        }
+        return result;
+    
+    }
+
+    // map of available grammars.
+    public Map<String, List<String>> getGrammars() {
+        return this.grammarMap;
+    }
+
+    // list of grammars. 
+    public List<String> getGrammarList() {
+        return this.grammarList;
+    }
+
+    // all the keys/nonterminals of the grammer
+    public String getSymbols() {
+        return this.getGrammars().keySet().toString();
+    }
+
+    // grammer contains a terminal key.
+    public boolean grammarContains(String key) {
+        return this.getGrammars().keySet().contains(key);
+    }
+
+    /**
+    *
+    * Private Helper Methods
+    *
+    */
+
+    // recursively evaluate grammar
+    private String generate(String symbol) {
+        String result = "";
+        Set<String> symbols = this.getGrammars().keySet();
+
+        // base case
+        if(this.grammarContains(symbol) != true ) {
+            return "";
+        }
+        String rule = this.getRandomTerminal(symbol);
+
+        // apply the rules
+        for(String subRule : GrammarSolver.splitRule(rule)){
+            if( ! result.isEmpty()) {
+                result += " "; // keeps leading whitespace off.
+            }
+            if( this.grammarContains(subRule) ) { // test if a subrule is a nonterminal.
+                result += this.generate(subRule); // evaluates nonterminal rule and appends it.
+            } else {
+                result += subRule;
+            }
+        }
+        return result.trim();
+    }
+
+    // add grammar to grammars.
+    private void addEntry(String entry) {
+        String nonterminal = GrammarSolver.nonTerminal(entry);
+        List<String> rules = GrammarSolver.terminals(entry);
+        this.getGrammars().put(nonterminal, rules); 
+    }
+    
+    // line of a grammar is valid.
+    private boolean isValidEntry(String entry) {
+        // errors if bad colon count
+        int colonCount = entry.length() - entry.replace(":", "").length();
+        if( colonCount != 1) {
+            throw new IllegalArgumentException("does not contain single colon");
+        }
+
+        // errors if duplicate
+        String nonterminal = GrammarSolver.nonTerminal(entry);
+        if( this.getGrammars().keySet().contains(nonterminal) ) {
+            throw new IllegalArgumentException("duplicate non-terminal detected");
+        }
+        return true;
+    }
+
+    // random element of a non-terminal's rules.
+    private String getRandomTerminal(String symbol) {
+        Random random = new Random();
+        List<String> rules = this.getGrammars().get(symbol);
+        int index = random.nextInt(rules.size());
+        return rules.get(index);
+    }
+
+
+
+    /**
+    *
+    * Static Methods
+    *
+    */
+
+    // splits a string of rules at the whitespaces.
+    private static String[] splitRule(String rule) {
+        String[] split =  rule.split("[ \t]");
+        return split;
+    }
+
+    // pre: no whitespace.
+    // pre: non-empty.
+    public static String nonTerminal(String entry) {
+        return entry.substring(0, entry.indexOf(':'));
+    }
+
+    // extracts terminals from a string.
+    public static List<String> terminals(String entry) {
+        List<String> rules = new ArrayList<String>();
+        entry = entry.substring(entry.indexOf(':') + 1, entry.length());
+        String[] exploded = entry.split("\\|");
+        for(int i = 0; i < exploded.length; i++) {
+            rules.add(exploded[i]);
+        }
+        return rules;
+    }
+}

src/main/java/com/matthewjensen/project/modules/grammer/GrammarTest.java

@@ -0,0 +1,206 @@
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertArrayEquals;
+import org.junit.Test;
+import java.util.*;
+
+public class GrammarTest {
+
+    @Test
+    public void testMixedNonAndTerminals() {
+        List<String> grammar = new ArrayList<String>();
+        grammar.add("<a>:<b> <c>|<b>");
+        grammar.add("<b>:Test");
+        grammar.add("<c>:");
+        GrammarSolver solver = new GrammarSolver(grammar);
+        String[] result = solver.generate("<a>", 1);
+        String[] expected = new String[1]; 
+        Arrays.fill(expected, "Test");
+        assertArrayEquals(expected, result);
+    }
+    @Test(expected = IllegalArgumentException.class) 
+    public void testGenerateNonTermDoesntExist() {
+        List<String> grammar = new ArrayList<String>();
+        grammar.add("<a>:Test|:Other");
+        GrammarSolver solver = new GrammarSolver(grammar);
+        solver.generate("<b>", 1);
+    }
+
+    @Test(expected = IllegalArgumentException.class) 
+    public void testGenerateTimesInvalid() {
+        List<String> grammar = new ArrayList<String>();
+        grammar.add("<a>:Test|:Other");
+        GrammarSolver solver = new GrammarSolver(grammar);
+        solver.generate("<a>", 0);
+        solver.generate("<a>", -1);
+    }
+
+    @Test
+    public void testGenerate() {
+        String[] expected = new String[2]; 
+        Arrays.fill(expected, "Test");
+
+        List<String> grammar = new ArrayList<String>();
+        grammar.add("<a>:Test");
+        GrammarSolver solver = new GrammarSolver(grammar);
+
+        String[] result = solver.generate("<a>", 2);
+        assertArrayEquals(expected, result);
+    }
+
+    @Test
+    public void testMultipleRulePaths() {
+        String[] expected = new String[3]; 
+        Arrays.fill(expected, "Test Nest");
+
+        List<String> grammar = new ArrayList<String>();
+        grammar.add("<a>:<b> <c>");
+        grammar.add("<b>:Test");
+        grammar.add("<c>:Nest");
+        GrammarSolver solver = new GrammarSolver(grammar);
+
+        String[] result = solver.generate("<a>", 3);
+        assertArrayEquals(expected, result);
+    }
+    @Test
+    public void testMultipleSymbolsAsRules() {
+        String[] expected = new String[3]; 
+        Arrays.fill(expected, "Nest Nest");
+
+        List<String> grammar = new ArrayList<String>();
+        grammar.add("<a>:<b> <c>");
+        grammar.add("<b>:<c>");
+        grammar.add("<c>:Nest");
+        GrammarSolver solver = new GrammarSolver(grammar);
+
+        String[] result = solver.generate("<a>", 3);
+        assertArrayEquals(expected, result);
+    }
+
+    @Test
+    public void testGenerateNestedTwice() {
+        String[] expected = new String[3]; 
+        Arrays.fill(expected, "Nest");
+
+        List<String> grammar = new ArrayList<String>();
+        grammar.add("<a>:<b>");
+        grammar.add("<b>:<c>");
+        grammar.add("<c>:Nest");
+        GrammarSolver solver = new GrammarSolver(grammar);
+
+        String[] result = solver.generate("<a>", 3);
+        assertArrayEquals(expected, result);
+    }
+    @Test
+    public void testGenerateNested() {
+        String[] expected = new String[2]; 
+        Arrays.fill(expected, "Nest");
+
+        List<String> grammar = new ArrayList<String>();
+        grammar.add("<a>:<b>");
+        grammar.add("<b>:Nest");
+        GrammarSolver solver = new GrammarSolver(grammar);
+
+        String[] result = solver.generate("<a>", 2);
+        assertArrayEquals(expected, result);
+    }
+    @Test
+    public void testGrammarListImmutable() {
+        List<String> grammar = new ArrayList<String>();
+        grammar.add("<a>:Test");
+        GrammarSolver solver = new GrammarSolver(grammar);
+        String expected = grammar.get(0);
+        String actual = solver.getGrammarList().get(0);
+        assertEquals("got back different than instantiation.", expected, actual);
+        assertArrayEquals("different grammars.", grammar.toArray(), solver.getGrammarList().toArray());
+    }
+    @Test
+    public void testGrammarListImmutableWithPipe() {
+        List<String> grammar = new ArrayList<String>();
+        grammar.add("<a>:Test|Other");
+        GrammarSolver solver = new GrammarSolver(grammar);
+        assertArrayEquals("different grammars.", grammar.toArray(), solver.getGrammarList().toArray());
+    }
+
+    @Test
+    public void testNonTerminalExtract() {
+        String entry = "<a>:Test";
+        String expected = "<a>";
+        String actual = GrammarSolver.nonTerminal(entry);
+        assertEquals("failure - extraction failed", expected, actual);
+    }
+    @Test
+    public void testRuleExtractContent() {
+        String entry = "<a>:Test";
+        List<String> expected = new ArrayList<String>();
+        expected.add("Test");
+        List<String> actual = GrammarSolver.terminals(entry);
+        assertArrayEquals("failure - rule extraction failed", expected.toArray(), actual.toArray());
+    }
+    @Test
+    public void testRuleCount() {
+        String entry = "<a>:Test";
+        List<String> expected = new ArrayList<String>();
+        expected.add("Test");
+        List<String> actual = GrammarSolver.terminals(entry);
+        assertEquals("rule count different", expected.size(), actual.size());
+    }
+
+    @Test(expected = IllegalArgumentException.class) 
+    public void testNoColon() { 
+        List<String> grammar = new ArrayList<String>();
+        grammar.add("test");
+        GrammarSolver solver = new GrammarSolver(grammar);
+    }
+
+    @Test(expected = IllegalArgumentException.class) 
+    public void testDuplicateGrammar() { 
+        List<String> grammar = new ArrayList<String>();
+        grammar.add("<a>:Test|Other");
+        grammar.add("<a>:Test|Other");
+        GrammarSolver solver = new GrammarSolver(grammar);
+    }
+
+    @Test(expected = IllegalArgumentException.class) 
+    public void testGrammarContainsSingleColon() {
+        List<String> grammar = new ArrayList<String>();
+        grammar.add("<a>:Test|:Other");
+        GrammarSolver solver = new GrammarSolver(grammar);
+    }
+
+    @Test
+    public void testGrammarContains() {
+        List<String> grammar = new ArrayList<String>();
+        grammar.add("<a>:Test");
+        GrammarSolver solver = new GrammarSolver(grammar);
+        assertEquals(true, solver.grammarContains("<a>"));
+        assertEquals(false, solver.grammarContains("a"));
+        assertEquals(false, solver.grammarContains("<b>"));
+    }
+    @Test
+    public void testGrammarContainsCaseInsensitive() {
+        List<String> grammar = new ArrayList<String>();
+        grammar.add("<a>:Test");
+        GrammarSolver solver = new GrammarSolver(grammar);
+        assertEquals(true, solver.grammarContains("<a>"));
+        assertEquals(false, solver.grammarContains("<A>"));
+    }
+
+    @Test
+    public void testGetSymbols() {
+        List<String> grammar = new ArrayList<String>();
+        grammar.add("<a>:Test");
+        grammar.add("<b>:Test|Other");
+        GrammarSolver solver = new GrammarSolver(grammar);
+        assertEquals("[<a>, <b>]", solver.getSymbols());
+    }
+    @Test
+    public void testGetSymbolsSorted() {
+        List<String> grammar = new ArrayList<String>();
+        grammar.add("<C>:Test|Other");
+        grammar.add("<A>:Test");
+        grammar.add("<b>:Test|Other");
+        GrammarSolver solver = new GrammarSolver(grammar);
+        assertEquals("[<A>, <C>, <b>]", solver.getSymbols());
+    }
+}

src/main/java/com/matthewjensen/project/modules/grammer/sentence.txt

@@ -0,0 +1,10 @@
+<s>:<np> <vp>
+<np>:<dp> <adjp> <n>|<pn>
+<pn>:John|Jane|Sally|Spot|Fred|Elmo
+<adjp>:<adj>|<adj> <adjp>
+<adj>:big|fat|green|wonderful|faulty|subliminal|pretentious
+<dp>:the|a
+<n>:dog|cat|man|university|father|mother|child|television
+<vp>:<tv> <np>|<iv>
+<tv>:hit|honored|kissed|helped
+<iv>:died|collapsed|laughed|wept

src/main/java/com/matthewjensen/project/modules/grammer/sentence2.txt

@@ -0,0 +1,5 @@
+E:    T     |		E		OP     T    
+T:   x    |   y   |   42  | 0 | 1 | 92 | ( E ) | F1 ( E ) | - T | F2 ( E , E )
+OP:    +   |      -    |   *       |   %	 |	  /	 
+F1:   sin    | cos|    tan  |sqrt   | abs  
+F2:max	     |min       |   pow	      

src/main/java/com/matthewjensen/project/modules/hangman/HangmanMain.java

@@ -0,0 +1,85 @@
+// Class HangmanMain is the driver program for the Hangman program.  It reads a
+// dictionary of words to be used during the game and then plays a game with
+// the user.  This is a cheating version of hangman that delays picking a word
+// to keep its options open.  You can change the setting for SHOW_COUNT to see
+// how many options are still left on each turn.
+
+import java.util.*;
+import java.io.*;
+
+public class HangmanMain {
+	public static final String DICTIONARY_FILE = "dictionary2.txt";
+	public static final boolean DEBUG = true; // show words left
+
+	public static void main(String[] args) throws FileNotFoundException {
+		System.out.println("Welcome to the cs 145 hangman game.");
+		System.out.println();
+
+		// open the dictionary file and read dictionary into an ArrayList
+		Scanner input = new Scanner(new File(DICTIONARY_FILE));
+		List<String> dictionary = new ArrayList<String>();
+		while (input.hasNext()) {
+			dictionary.add(input.next().toLowerCase());
+		}
+
+		// set basic parameters
+		Scanner console = new Scanner(System.in);
+		System.out.print("What length word do you want to use? ");
+		int length = console.nextInt();
+		System.out.print("How many wrong answers allowed? ");
+		int max = console.nextInt();
+		System.out.println();
+
+		// set up the HangmanManager and start the game
+		List<String> dictionary2 = Collections.unmodifiableList(dictionary);
+		HangmanManager hangman = new HangmanManager(dictionary2, length, max);
+		if (hangman.words().isEmpty()) {
+			System.out.println("No words of that length in the dictionary.");
+		} else {
+			playGame(console, hangman);
+			showResults(hangman);
+		}
+	}
+
+	// Plays one game with the user
+	public static void playGame(Scanner console, HangmanManager hangman) {
+		while (hangman.guessesLeft() > 0 && hangman.pattern().contains("-")) {
+			System.out.println("guesses : " + hangman.guessesLeft());
+			if (DEBUG) {
+				System.out.println(hangman.words().size() + " words left: "
+						+ hangman.words());
+			}
+			System.out.println("guessed : " + hangman.guesses());
+			System.out.println("current : " + hangman.pattern());
+			System.out.print("Your guess? ");
+			char ch = console.next().toLowerCase().charAt(0);
+			if (hangman.guesses().contains(ch)) {
+				System.out.println("You already guessed that");
+			} else {
+				int count = hangman.record(ch);
+				if (count == 0) {
+					System.out.println("Sorry, there are no " + ch + "'s");
+				} else if (count == 1) {
+					System.out.println("Yes, there is one " + ch);
+				} else {
+					System.out.println("Yes, there are " + count + " " + ch
+							+ "'s");
+				}
+			}
+			System.out.println();
+		}
+	}
+
+	// reports the results of the game, including showing the answer
+	public static void showResults(HangmanManager hangman) {
+		// if the game is over, the answer is the first word in the list
+		// of words, so we use an iterator to get it
+		String answer = hangman.words().iterator().next();
+		System.out.println("answer = " + answer);
+		if (hangman.guessesLeft() > 0) {
+			System.out.println("You beat me");
+		} else {
+			System.out.println("Sorry, you lose");
+		}
+	}
+}

src/main/java/com/matthewjensen/project/modules/hangman/HangmanManager.java

@@ -0,0 +1,224 @@
+/*
+* Matt Jensen
+* CS145 - Lab 4
+* 5/21/19
+*
+// runs the hangman game
+*/
+import java.util.*;
+
+public class HangmanManager {
+
+    private List<String> dictionary;
+    private Set<String> words;
+    private int length;
+    private int max;
+    private SortedSet<Character> guesses;
+    private int tries;
+
+    /**
+    *
+    * @param   dictionary    contains all the possible solutions.
+    * @param   length   length of solutions.
+    * @param   max   maximum guesses.
+    * @return   manager
+    *
+    */
+    public HangmanManager(List<String> dictionary, int length, int max) {
+        if(length < 1 || max < 0){
+            throw new IllegalArgumentException("length or max are incorrect");
+        }
+        this.setDictionary(dictionary);
+        this.setLength(length);
+        this.setMax(max);
+        this.setTries(0);
+        this.setGuesses();
+        this.setWords();
+    }
+
+    /**
+    * set of words being considered my manager.
+    *
+    * @return   words
+    *
+    */
+    public Set<String> words()  {
+        return this.words;
+    }
+
+    /**
+    * guesses the player has left in the game.
+    *
+    */
+    public int guessesLeft() {
+        return this.max - this.tries;
+    }
+
+    /**
+    * past guesses by player.
+    *
+    * @return   guesses
+    *
+    */
+    public SortedSet<Character> guesses() {
+        return this.guesses;
+    }
+
+    /**
+    * representation of the current state of the game.
+    *
+    * @return   pattern
+    *
+    */
+    public String pattern() {
+        if(this.getWords().isEmpty()){
+            throw new IllegalStateException("words are empty");
+        }
+        String word = this.getWords().iterator().next();
+        return pattern(word, this.getGuesses());
+    }
+    // generated the string mask for a word given a set of guessses.
+    public static String pattern(String word, Set<Character> guessMask) {
+        String pattern = "";
+        for( int i = 0; i < word.length(); i++) {
+            if( guessMask.contains(word.charAt(i)) ) {
+                pattern += " " + word.charAt(i);
+            } else {
+                pattern += " -";
+            }
+        }
+        return pattern;
+          
+    }
+
+    // accessor for guesses set.
+    private SortedSet<Character> getGuesses() {
+        return this.guesses;
+    }
+
+    /**
+    * records a guess.
+    *
+    * @return   matches     number of matches of the guess.
+    *
+    */
+    public int record(char guess) {
+        if(this.guessesLeft() < 1){
+            throw new IllegalStateException("no tries left");
+        }
+        if( ! this.getWords().isEmpty() && this.getGuesses().contains(guess)){
+            throw new IllegalArgumentException();
+        }
+        int count = 0;
+        this.addGuess(guess);
+        // maps a count to and array of possibilities
+
+        SortedMap<String, List<String>> possibilities = getPossibilities(guess);
+        if( possibilities.size() >= 1 ) {
+            this.setWords(mostEvil(possibilities));
+        }
+        count = countMatches(this.getWords().iterator().next(), guess);
+        if(count == 0){
+            this.addTry();
+        }
+        return count;
+    }
+    /**
+     * counts number of chars in word
+     * 
+     * @param word
+     * @param character
+     * @return
+     */
+    public static int countMatches(String word, char character){
+        int count = 0;
+        for(int i = 0; i < word.length(); i++){
+            if(word.charAt(i) == character){
+                count++;
+            }
+        }
+        return count;
+    }
+    /**
+     * returns the most evil list of words in the map.
+     * @param map   the map of all possible values.
+     * @return  list of the most evil words.
+     */
+    private List<String> mostEvil(Map<String, List<String>> map){
+        // check if the key is the smallest guess.gg
+        String maxKey = "";
+        int maxCount = 0;
+        for(String key : map.keySet()){
+            if( map.get(key).size() > maxCount) {
+                maxKey = key;
+                maxCount = map.get(key).size();
+            }
+        }
+        return map.get(maxKey);
+    }
+    /**
+     * get a map with patterns as keys and words as values.
+     * 
+     * @param guess     the additional guess.
+     * @return  possibilities   the possible words
+     */
+    private SortedMap<String, List<String>> getPossibilities(char guess) {
+        SortedMap<String, List<String>> map = new TreeMap<String, List<String>>();
+        String pattern = "";
+        Set<String> keys = new HashSet<String>();
+        for(String word : this.getWords()) {
+            keys.add(pattern(word, this.getGuesses()));
+        }
+        for(String key : keys){
+            map.put(key, new ArrayList<String>());
+        }
+        for(String word : this.getWords()) {
+            pattern = pattern(word, this.getGuesses());
+            map.get(pattern).add(word);
+        }
+        return map;
+    }
+
+    /**
+     * 
+     * Setters and Getters for object attributes.
+     * 
+     */
+    
+    private Set<String> getWords() {
+        return this.words;
+    }
+    private void addGuess(char guess) {
+        this.guesses.add(guess);
+    }
+
+    private void setDictionary(List<String> dictionary) {
+        this.dictionary = dictionary;
+    }
+    private void setLength(int length) {
+        this.length = length;
+    }
+    private void setMax(int max) {
+        this.max = max;
+    }
+    private void setTries(int tries) {
+        this.tries = tries;
+    }
+    private void addTry(){
+        this.tries++;
+    }
+    private void setGuesses() {
+        this.guesses = new TreeSet<Character>();
+    }    
+    private void setWords() {
+        this.setWords(this.dictionary);
+    }
+    private void setWords(List<String> words) {
+        this.words = new TreeSet<String>();
+        for(String word : words) {
+            if( word.length() == this.length) {
+                this.words.add(word);
+            }
+        }
+    }
+}

src/main/java/com/matthewjensen/project/modules/hangman/dictionary2.txt

@@ -0,0 +1,9 @@
+ally
+beta
+cool
+deal
+else
+flew
+good
+hope
+ibex

src/main/java/com/matthewjensen/project/modules/phonebook/PhoneBook.java

@@ -0,0 +1,85 @@
+/*
+*
+* Matt Jensen
+* CS 145, Spring 2019
+* Assignment X
+* 5/15/19
+*
+*/
+
+// stores telephone nodes
+import java.util.*;
+
+public class PhoneBook {
+
+    private String name;
+    private TelephoneNode front;
+    private TelephoneNode back;
+    private int size;
+
+    public PhoneBook( String name ) {
+        this.name = name;
+        this.size = 0;
+    }
+    public void add(TelephoneNode node) {
+        this.add(this.size, node);
+    }
+    public void add( int index, TelephoneNode node ) {
+        if( index == 0 ) {
+            node.next = this.front;
+            this.front = node;
+        } else {
+            TelephoneNode nodeBeforeIndex = this.get( index - 1 );
+            //TelephoneNode nodeAtIndex = this.get( index );
+            //node.next = nodeAtIndex.next;
+            nodeBeforeIndex.next = node;
+        }
+        this.size++;
+    }
+    public TelephoneNode get(int index) {
+        TelephoneNode currentNode = this.front;
+        for( int i = 0; i < index; i++) {
+            currentNode = currentNode.next;
+        }
+        return currentNode; // change back.next from null to node
+    }
+    public int search(String name) {
+        TelephoneNode currentNode = this.front;
+        name = name.toLowerCase();
+        String nodeName;
+        for( int i = 0; i < this.size; i++) {
+            nodeName = currentNode.getName().toLowerCase();
+            if(nodeName.indexOf(name) >= 0) {
+                return i;
+            }
+            currentNode = currentNode.next;
+        }
+        return -1;
+    }
+    public void transfer(int index, PhoneBook destination){
+        TelephoneNode node = this.get(index);
+        this.remove(index);
+        destination.add(node);
+    }
+    public void remove(int index) {
+        if( index == 0 ) {
+            this.front = this.front.next;
+        } else {
+            TelephoneNode nodeBeforeIndex = this.get( index - 1 );
+            TelephoneNode nodeAtIndex = this.get( index );
+            nodeBeforeIndex.next = nodeAtIndex.next;
+        }
+    }
+    public String getName() {
+        return this.name;
+    }
+    public String toString() {
+        String string = this.getName() + "\n";
+        TelephoneNode currentNode = this.front; 
+        while( currentNode != null ) {
+            string += currentNode.toString() + "\n"; 
+            currentNode = currentNode.next;
+        }
+        return string;
+    }
+}

src/main/java/com/matthewjensen/project/modules/phonebook/PhoneBookClient.java

@@ -0,0 +1,133 @@
+/*
+*
+* Matt Jensen
+* CS 145, Spring 2019
+* Assignment X
+* 5/15/19
+*
+*/
+
+import java.util.*;
+import java.awt.*;
+import java.io.*;
+
+public class PhoneBookClient {
+
+    // holds the clients phonebooks
+    private static ArrayList<PhoneBook> phonebooks = new ArrayList<PhoneBook>();
+
+    // controls the command prompt and manages class relationships.
+    public static void main( String[] args ) {
+        //seed();
+        Scanner console = new Scanner( System.in );
+        Prompt.intro();
+        char option = Prompt.forOption(console);
+        String name;
+        PhoneBook phonebook = null;
+        TelephoneNode currentNode = null;
+        String[] data;
+        int index;
+        while(option != 'q') {
+            if( option == 'c') {
+                name = Prompt.forString(console);
+                System.out.println(name);
+                PhoneBook newPhonebook = new PhoneBook( name );
+                phonebooks.add(newPhonebook);
+            } else if( phonebooks.size() < 1 ) {
+                System.out.println("No phonebooks yet.");
+                System.out.println();
+                option = Prompt.forOption(console);
+                continue;
+            }
+            if( option == 'a' ) {
+                phonebook = phonebooks.get(Prompt.forPhoneBookIndexOf(phonebooks, console));
+                data = new String[3];
+                TelephoneNode newNode = new TelephoneNode(Prompt.forTelephoneNodeData(data, console));
+                phonebook.add(newNode);
+            }
+            if( option == 'r' ) {
+                index = Prompt.forPhoneBookIndexOf(phonebooks, console);
+                if( index != -1 ) {
+                    phonebook = phonebooks.get(index);
+                }
+                index = Prompt.forTelephoneNodeIndexOf(phonebook, console);
+                if( index != -1 ) {
+                    phonebook.remove(index);
+                }
+            }
+            if( option == 'm' ) {
+                index = Prompt.forPhoneBookIndexOf(phonebooks, console);
+                if( index != -1 ) {
+                    phonebook = phonebooks.get(index);
+                    index = Prompt.forTelephoneNodeIndexOf(phonebook, console);
+                    if( index != -1 ) {
+                        currentNode = phonebook.get(index);
+                        data = new String[3];
+                        data = Prompt.forTelephoneNodeData(data, console);
+                        currentNode.setAll(data);
+                    }
+                }
+            }
+            if( option == 'p' ) {
+                index = Prompt.forPhoneBookIndexOf(phonebooks, console);
+                if( index != -1 ) {
+                    phonebook = phonebooks.get(index);
+                }
+                System.out.println("PhoneBook:");
+                System.out.println(phonebook);
+            }
+            if( option == 's' ) {
+                index = Prompt.forPhoneBookIndexOf(phonebooks, console);
+                if( index != -1 ) {
+                    phonebook = phonebooks.get(index);
+                    index = Prompt.forTelephoneNodeIndexOf(phonebook, console);
+                    if( index != -1 ) {
+                        currentNode = phonebook.get(index);
+                        System.out.println("Entry Found:");
+                        System.out.println(currentNode);
+                    }
+                }
+            }
+            if( option == 't' ) {
+                index = Prompt.forPhoneBookIndexOf(phonebooks, console);
+                if( index != -1 ) {
+                    PhoneBook fromPhoneBook = phonebooks.get(index);
+                    index = Prompt.forTelephoneNodeIndexOf(fromPhoneBook, console);
+                    if( index != -1 ) {
+                        int nodeIndex = index;
+                        currentNode = fromPhoneBook.get(index);
+                        System.out.println("Destination:");
+                        index = Prompt.forPhoneBookIndexOf(phonebooks, console);
+                        PhoneBook toPhoneBook = phonebooks.get(index);
+                        fromPhoneBook.transfer(nodeIndex, toPhoneBook);
+                    }
+                }
+            }
+            System.out.println();
+            option = Prompt.forOption(console);
+        }
+        System.out.println("Goodbye!");
+        return;
+    }
+    private static void seed() {
+        PhoneBook book = new PhoneBook("Seattle");
+
+        String[] phoneName = new String[]{"Matt", "555555555", "1234 High St."};
+        book.add(new TelephoneNode(phoneName));
+
+        phoneName = new String[]{"Other", "2525252525", "5555 Main"};
+        book.add(new TelephoneNode(phoneName));
+
+        phoneName = new String[]{"And Another", "111111111", "5555 Main"};
+        book.add(new TelephoneNode(phoneName));
+
+        phonebooks.add(book);
+
+        book = new PhoneBook("Bellingham");
+        phoneName = new String[]{"Another", "000000000", "5555 Main"};
+        book.add(new TelephoneNode(phoneName));
+
+        phonebooks.add(book);
+
+    }
+}

src/main/java/com/matthewjensen/project/modules/phonebook/Prompt.java

@@ -0,0 +1,129 @@
+/*
+*
+* Matt Jensen
+* CS 145, Spring 2019
+* Assignment X
+* 5/15/19
+*
+*/
+
+import java.util.*;
+import java.awt.*;
+import java.io.*;
+
+public class Prompt {
+
+    private static String[] options = {"Create Directory", "Add Telephone to Directory", "Remove Telephone from Directory", "Modify a Telephone entry", "Tranfer a Telephone to New Directory", "Search a Directory", "Print Directory", "Quit"};
+    private static String[] values = {"c", "a", "r", "m", "t", "s", "p", "q"};
+    private static boolean DEBUG = false;
+
+    // print the introduction to the program on start up.
+    public static void intro() {
+        System.out.println("Welcome to my word search generator");
+        System.out.println("This program allows you to generate your own word search puzzle");
+    }
+    public static TelephoneNode forTelephoneNodeInPhoneBook(String name, PhoneBook phonebook, Scanner console) {
+        return phonebook.get(0);
+    }
+
+
+    // prompts from option input
+    // rejects options outside of class variable
+    public static char forOption( Scanner console ) {
+        String question = getOptionPrompt();
+        String input = prompt(question, console);
+        while(  ! isOption(input) ) {
+            System.out.println("Unrecognized input.");
+            input = prompt(question, console);
+        }
+        return getOption(input);
+    }
+    // prompts for string
+    public static String forString( Scanner console ) {
+        String input = prompt("City?", console);
+        return getString(input);
+    }
+    // prompts for telephonenode data
+    public static String[] forTelephoneNodeData( String[] data, Scanner console ) {
+        data[0]  = getString(prompt("Name?", console));
+        data[1]  = getString(prompt("Phone?", console));
+        data[2]  = getString(prompt("Address?", console));
+        return data;
+    }
+    // prompts for telephonenode data
+    public static int forTelephoneNodeIndexOf( PhoneBook phonebook, Scanner console ) {
+        String input = prompt("Which Telephone Entry?", console);
+        return phonebook.search(input);
+    }
+
+    // prompts for PhoneBook Name
+    public static int forPhoneBookIndexOf(ArrayList<PhoneBook> phonebooks, Scanner console ) {
+        String input = prompt("Which Phonebook?", console);
+        return getPhoneBookIndex(phonebooks, input);
+    }
+
+    public static boolean hasPhoneBookNamed(ArrayList<PhoneBook> phonebooks, String name) {
+        int index = 0;
+        PhoneBook current = phonebooks.get(index);
+        for(PhoneBook phonebook : phonebooks) {
+            if(index != 0) {
+                current = phonebooks.get(index);
+            }
+            if(current.getName().indexOf(name.toLowerCase()) >= 0) {
+                return true;
+            }
+            index++;
+        }
+        return false;
+    }
+
+    private static int getPhoneBookIndex(ArrayList<PhoneBook> phonebooks, String name) {
+        name = name.toLowerCase();
+        int index = 0;
+        String currentName = "";
+        PhoneBook current = phonebooks.get(index);
+        for(PhoneBook phonebook : phonebooks) {
+            if(index != 0) {
+                current = phonebooks.get(index);
+            }
+            currentName = current.getName().toLowerCase();
+            if(currentName.indexOf(name) >= 0) {
+                return index;
+            }
+            index++;
+        }
+        return -1;
+    }
+
+    // validates if character is an option
+    private static boolean isOption(String input) {
+        for(int i = 0; i < values.length; i++) {
+            if( input.startsWith(values[i]) ) {
+                return true;
+            }
+        }
+        return false;
+    }
+    private static String getString(String input) {
+        return input;
+    }
+    // return first character of input for options.
+    private static char getOption(String input) {
+        return input.charAt(0);
+    }
+    private static String prompt(String prompt, Scanner console) {
+        System.out.println(prompt);
+        String response = console.nextLine();
+        System.out.println();
+        return response;
+    }
+
+    // returns all the possible options
+    private static String getOptionPrompt() {
+        String prompt = "Please select an option below:\n";
+        for( int i = 0; i < options.length; i++ ) {
+            prompt += options[i] + " (" + values[i] + ")\n";
+        }
+        return prompt;
+    }
+}

src/main/java/com/matthewjensen/project/modules/phonebook/README.md

@@ -0,0 +1,2 @@
+# Phonebook
+

src/main/java/com/matthewjensen/project/modules/phonebook/TelephoneNode.java

@@ -0,0 +1,56 @@
+/*
+*
+* Matt Jensen
+* CS 145, Spring 2019
+* Assignment X
+* 5/15/19
+*
+*/
+
+// an individual telephone in a phone book.
+public class TelephoneNode {
+
+    private String name;
+    private String number;
+    private String address;
+
+    public TelephoneNode next;
+
+    public void setName(String name) {
+        this.name = name;
+    }
+    public void setAddress(String address) {
+        this.address = address;
+    }
+    public void setNumber(String number) {
+        this.number = number;
+    }
+    public String getName() {
+        return this.name;
+    }
+
+    public TelephoneNode() {
+        this(null, null);
+    }
+    public void setAll(String[] data){
+        this.setData(data);
+    }
+
+    public TelephoneNode(String[] data, TelephoneNode next) {
+        if( data != null ) {
+            this.setData(data);
+        }
+        this.next = next;
+    }
+    public TelephoneNode(String[] data) {
+        this(data, null);
+    }
+    private void setData(String[] data) {
+        this.name = data[0];
+        this.number = data[1];
+        this.address = data[2];
+    }
+    public String toString() {
+        return this.name + " " + this.address + " " + this.number;
+    }
+}

src/main/java/com/matthewjensen/project/modules/word-search/Board.java

@@ -0,0 +1,230 @@
+/*
+*
+* Matt Jensen
+* CS145
+* Assignment 1
+* 4/17/19
+* 
+*/
+import java.util.*;
+import java.awt.*;
+
+public class Board {
+    protected static enum Direction {
+        DOWN, UP, LEFT, RIGHT
+    };
+    protected char[][] board;
+    protected char[][] solution;
+    protected int size;
+    protected String[] unplacedWords;
+    protected String[] placedWords;
+    protected String[] allWords;
+    public Board(String[] words) {
+        setWords(words);
+        this.size = getMaxWordSize();
+        this.board = new char[size][size];
+        this.solution = new char[size][size];
+        placeWords();
+    }
+
+    public void placeWords() {
+        for( int i = 0; i < unplacedWords.length; i++) {
+            placeWord(unplacedWords[i]);
+        }
+    }
+
+
+    /**
+    *
+    * places a single word on the board.
+    * picks a random index i, j
+    * picks a random direction
+    *
+    * @return  boolean  the placement successful    
+    */
+    private void placeWord(String inputWord) {
+
+        Direction direction = randomDirection();
+        int rowIndex = (int) (Math.random() * (this.getSize()));
+        int columnIndex = (int) (Math.random() * (this.getSize()));
+
+        int placementTries = 0;
+        for(int tries = 0; tries < 100; tries++) {
+            if(isPlaced(inputWord, rowIndex, columnIndex, direction)){
+                for(int i = 0; i < this.placedWords.length; i++) {
+                    if(this.placedWords[i] == null) {
+                        placedWords[i] = inputWord;
+                        return;
+                    }
+                }
+                return;
+            }
+            direction = randomDirection();
+            rowIndex = (int) (Math.random() * (this.getSize()));
+            columnIndex = (int) (Math.random() * (this.getSize()));
+        }
+    }
+    private boolean isPlaced(String word, int rowIndex, int columnIndex, Direction direction) {
+        char[][] currentBoard = copyBoard(this.getBoard());
+        if( direction == Direction.DOWN ) {
+            for( int i = 0; i < word.length(); i++) {
+                if( currentBoard[i][columnIndex] == 0) {
+                    currentBoard[i][columnIndex] = word.charAt(i);
+
+                } else if( currentBoard[i][columnIndex] == word.charAt(i)){
+            
+                    currentBoard[i][columnIndex] = word.charAt(i);
+                }
+                else {
+                    return false;
+                }
+            }
+        }
+        if( direction == Direction.UP ) {
+            for( int i = 0; i < word.length(); i++) {
+                if( currentBoard[word.length() - i - 1][columnIndex] == 0) {
+                    currentBoard[word.length() - i - 1][columnIndex] = word.charAt(i);
+                } else if( currentBoard[word.length() - i - 1][columnIndex] == word.charAt(i)){
+                    currentBoard[word.length() - i - 1][columnIndex] = word.charAt(i);
+                }
+                else {
+                    return false;
+                }
+            }
+        }
+        if( direction == Direction.LEFT ) {
+            for( int i = 0; i < word.length(); i++) {
+                if( currentBoard[rowIndex][word.length() - i - 1] == 0) {
+                    currentBoard[rowIndex][word.length() - i - 1] = word.charAt(i);
+                } else if( currentBoard[rowIndex][word.length() - i - 1] == word.charAt(i)){
+                    currentBoard[rowIndex][word.length() - i - 1] = word.charAt(i);
+                }
+                else {
+                    return false;
+                }
+            }
+        }
+        if( direction == Direction.RIGHT ) {
+            for( int i = 0; i < word.length(); i++) {
+                if( currentBoard[rowIndex][i] == 0) {
+                    currentBoard[rowIndex][i] = word.charAt(i);
+
+                } else if( currentBoard[rowIndex][i] == word.charAt(i)){
+            
+                    currentBoard[rowIndex][i] = word.charAt(i);
+                }
+                else {
+                    return false;
+                }
+            }
+        }
+        setBoard(currentBoard);
+        return true;
+    }
+    public char[][] getBoard() {
+        return this.board;
+    }
+    private void setBoard(char[][] newBoard) {
+        this.board = copyBoard(newBoard);
+        this.solution = copyBoard(newBoard);
+    }
+    private static char[][] copyBoard(char[][] old) {
+        if (old == null) {
+            return null;
+        }
+        char[][] result = new char[old.length][];
+        for (int r = 0; r < old.length; r++) {
+            result[r] = old[r].clone();
+        }
+        return result;
+    }
+
+    /**
+    *
+    * get board size based on largest word input.
+    *
+    * @return  void    
+    */
+    private int getMaxWordSize() {
+        int max = 0;
+        for( int i = 0; i < allWords.length; i++) {
+            if( allWords[i].length() > max ) {
+                max = allWords[i].length();
+            }
+        }
+        return max;
+    }
+    public void setWords(String[] words){
+        this.allWords = words;
+        this.unplacedWords = words;
+        this.placedWords = new String[words.length];
+    }
+    public int getSize() {
+        return this.size;
+    }
+
+    public String toString() {
+        return "Hidden Words:\n" 
+            + this.placedWordsToString() + "\n" 
+            + boardToString(this.getBoard(), false);
+    }
+    public String solutionToString() {
+        return "Words:\n" 
+            + this.placedWordsToString() + "\n" 
+            + boardToString(this.getBoard(), true);
+    }
+    public String[] getPlacedWords() {
+        return this.placedWords;
+    }
+    private String placedWordsToString() {
+        String result = "";
+        for(int i = 0; i < this.getPlacedWords().length; i++) {
+            if( this.getPlacedWords()[i] != null ) {
+                result = result +  "| " + this.getPlacedWords()[i] + " ";
+            }
+        }
+        return result + "|\n";
+    }
+    private static String boardToString(char[][] boardForPrint, boolean solutions) {
+        char[] CHAR_ALPHA = "abcdefghijklmnopqrstuvwxyz".toCharArray();
+        Random random = new Random(CHAR_ALPHA.length);
+        String text = "";
+        for(int i = 0; i < boardForPrint.length; i++) {
+            text = text + "| ";
+            for(int j = 0; j < boardForPrint[i].length; j++) {
+                if(boardForPrint[i][j] == 0) {
+                    if(solutions) {
+                        text = text + "- ";
+                    } else {
+                        int randomCharIndex = random.nextInt(CHAR_ALPHA.length);
+                        char randomChar = CHAR_ALPHA[randomCharIndex];
+                        text = text + randomChar + " ";
+                    }
+                } else {
+                    text = text + boardForPrint[i][j] + " ";
+                }
+            }
+            text = text + "|\n";
+        }
+        return text;
+
+    }
+
+    protected static Direction randomDirection() {
+        int index = (int) (Math.random() * 4);
+        
+        if( index == 0) {
+            return Direction.UP;
+        }
+        if( index == 1) {
+            return Direction.DOWN;
+        }
+        if( index == 2) {
+            return Direction.RIGHT;
+        }
+        if( index == 3) {
+            return Direction.LEFT;
+        }
+        return Direction.UP;
+    }
+}

src/main/java/com/matthewjensen/project/modules/word-search/ConsolePrompt.java

@@ -0,0 +1,158 @@
+/*
+*
+* Matt Jensen
+* CS145
+* Assignment 1
+* 4/25/19
+* 
+*/
+
+import java.util.*;
+import java.awt.*;
+import java.io.*;
+
+public class ConsolePrompt {
+
+    private static String[] options = {"Generate a new word search", "Print out your word search", "Show the solutions to your word search", "Quit the program"};
+    private static String[] values = {"g", "p", "s", "q"};
+    private static boolean DEBUG = false;
+
+    // print the introduction to the program on start up.
+    public static void intro() {
+        System.out.println("Welcome to my word search generator");
+        System.out.println("This program allows you to generate your own word search puzzle");
+    }
+
+    // prompts for words. 
+    // puts them in an array.
+    // pulls from a file if not null
+    public static String[] forWords(int count, String fileName,  Scanner console) throws FileNotFoundException {
+        String[] words = new String[count];
+        if(fileName != null) {
+            Scanner scanner = new Scanner(new File("words.txt"));
+            for(int i = 0; i < words.length; i++) {
+                words[i] = scanner.nextLine();
+            }
+        }
+        else {
+            String question = "Next word:";
+            String input = "";
+            for(int i = 0; i < words.length; i++) {
+                input = prompt(question, console);
+                words[i] = input;
+            }
+        
+        }
+        return words;
+    }
+
+    // prompts for filename
+    // TODO: check for file existance
+    public static String forFileName( Scanner console) {
+        String question = "Generate from file?";
+        boolean fromFile = forBoolean(question, console);
+        if(!fromFile) {
+            return null;
+        }
+        question = "Filename?";
+        String fileName = prompt(question, console);
+        while(  ! isFile(fileName) ) {
+            System.out.println("Unrecognized input.");
+            fileName = prompt(question, console);
+        }
+        return fileName;
+    }
+    
+    // prompts for word cound
+    // prompts again if not an integer
+    public static int forWordCount(Scanner console) {
+        String question = "How many words would you like to include in the word search?";
+        String input = prompt(question, console);
+        while(  ! isInteger(input) ) {
+            System.out.println("Unrecognized input.");
+            input = prompt(question, console);
+        }
+        return getInteger(input);
+    }
+
+    // TODO: validate if an integer
+    private static boolean isInteger(String input) {
+        return true;
+    }
+    // TODO: validate if file exists
+    private static boolean isFile(String input) {
+        return true;
+    }
+    // gets integer form input
+    private static int getInteger(String input) {
+        return Integer.parseInt(input);
+    }
+
+    private static String getString(String input) {
+        return input;
+    }
+
+    private static String prompt(String prompt, Scanner console) {
+        System.out.println(prompt);
+        String response = console.next();
+        System.out.println();
+        return response;
+    }
+    // returns all the possible options
+    public static String getOptionPrompt() {
+        String prompt = "Please select an option below:\n";
+        for( int i = 0; i < options.length; i++ ) {
+            prompt += options[i] + " (" + values[i] + ")\n";
+        }
+        return prompt;
+    }
+
+    // prompts from option input
+    // rejects options outside of class variable
+    public static char forOption( Scanner console ) {
+        String question = getOptionPrompt();
+        String input = prompt(question, console);
+        while(  ! isOption(input) ) {
+            System.out.println("Unrecognized input.");
+            input = prompt(question, console);
+        }
+        return getOption(input);
+    }
+    // validates if character is an option
+    private static boolean isOption(String input) {
+        for(int i = 0; i < values.length; i++) {
+            if( input.startsWith(values[i]) ) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // return first character of input for options.
+    private static char getOption(String input) {
+        return input.charAt(0);
+    }
+    
+    // prompts for boolean value
+    public static boolean forBoolean( String prompt, Scanner console ) {
+        String input = prompt(prompt, console);
+        while(  ! isBooleanInput(input) ) {
+            System.out.println("Unrecognized input.");
+            input = prompt(prompt, console);
+        }
+        return getBooleanInput(input);
+    }
+    // validates boolean value
+    private static boolean isBooleanInput(String input) {
+        return input.startsWith("y") || input.startsWith("Y") || input.startsWith("n") || input.startsWith("N");
+    }
+    // convert string input to boolean value.
+    private static boolean getBooleanInput(String input) {
+        if(input.startsWith("y") || input.startsWith("Y")) {
+            return true;
+        }
+        if(input.startsWith("n") || input.startsWith("N")) {
+            return false;
+        }
+        return false;
+    }
+}

src/main/java/com/matthewjensen/project/modules/word-search/README.md

@@ -0,0 +1,11 @@
+# Word Search Generator
+
+## topics
+Printing, data types, methods, operators, expressions, variables, for loop,
+parameters, returns, String objects, Scanner object, if/else statements, while loop, arrays
+
+## Learning Outcomes:
+- Begin to become familiar with setup, design, execution and testing of basic Java programs
+- Design and develop a multi-method program in good style
+- Demonstrate the ability to decompose a problem and reduce redundancy using methods
+- Apply tools and techniques introduced in class to form a workin

src/main/java/com/matthewjensen/project/modules/word-search/WordSearch.java

@@ -0,0 +1,81 @@
+/*
+*
+* Matt Jensen
+* CS145
+* Assignment 1
+* 4/25/19
+* 
+*/
+
+import java.util.*;
+import java.awt.*;
+import java.io.*;
+
+public class WordSearch {
+
+    protected static boolean DEBUG;
+    protected static Board board;
+    private static int wordCount = 20;
+
+    public static void main( String[] args ) throws FileNotFoundException {
+        Scanner console = new Scanner( System.in );
+        ConsolePrompt.intro();
+        char option = ConsolePrompt.forOption(console);
+        while(option != 'q') {
+            if(option == 'g') {
+                String fileName = ConsolePrompt.forFileName(console);
+                generate(fileName, console);
+            }
+            if(option == 's') {
+                showSolution(console);
+            }
+            if(option == 'p') {
+                showBoard(console);
+            }
+            System.out.println();
+            option = ConsolePrompt.forOption(console);
+        }
+        System.out.println("Goodbye!");
+        return;
+    }
+
+    /**
+    *
+    * generates a new board from the set words.
+    *
+    * @param   console console for printing prompts to.
+    * @return  void    
+    */
+    protected static void generate(String fromFile, Scanner console) throws FileNotFoundException {
+        int wordCount = ConsolePrompt.forWordCount(console);
+        board = new Board(
+            ConsolePrompt.forWords(wordCount, fromFile, console)
+        );
+    }
+    
+
+
+
+    /**
+    *
+    * prints the solution (x's for letters between words)
+    *
+    * @param   console console for printing prompts to.
+    * @return  void    
+    */
+    protected static void showSolution(Scanner console) {
+        System.out.println(board.solutionToString());
+    }
+
+    /**
+    *
+    * prints the entire board with words.
+    *
+    * @param   console console for printing prompts to.
+    * @return  void    
+    */
+    protected static void showBoard(Scanner console) {
+        System.out.println(board);
+    }
+
+}

src/main/java/com/matthewjensen/project/modules/word-search/words.txt

@@ -0,0 +1,24 @@
+spell
+tremble
+page
+embarrass
+care
+oval
+close
+believe
+hall
+magenta
+count
+shade
+tight
+utopian
+haunt
+wary
+tent
+bomb
+complain
+preserve
+thirsty
+curve
+design
+flippant

src/main/resources/application.properties

@@ -0,0 +1 @@
+

src/test/java/com/matthewjensen/project/ProjectApplicationTests.java

@@ -0,0 +1,13 @@
+package com.matthewjensen.project;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class ProjectApplicationTests {
+
+	@Test
+	void contextLoads() {
+	}
+
+}