add initial files l8

58 files changed, 17950 insertions, 0 deletions

diff --git a/labb8/lib/StanfordCPPLib/console.cpp b/labb8/lib/StanfordCPPLib/console.cpp
new file mode 100755
index 0000000..c55564c
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/console.cpp
@@ -0,0 +1,164 @@
+/*
+ * File: console.cpp
+ * -----------------
+ * This file implements the console.h interface.
+ */
+
+#include <string>
+#include "console.h"
+#include "error.h"
+#include "platform.h"
+using namespace std;
+
+static void sclTerminateHandler();
+
+static Platform *pp = getPlatform();
+static bool consoleEcho = false;
+static bool consolePrintExceptions = false;
+static string consoleLogFile = "";
+static void (*old_terminate)() = NULL;
+
+void clearConsole() {
+   pp->clearConsole();
+}
+
+bool getConsoleEcho() {
+   return consoleEcho;
+}
+
+string getConsoleLogFile() {
+   return consoleLogFile;
+}
+
+bool getConsolePrintExceptions() {
+    return consolePrintExceptions;
+}
+
+void setConsoleEcho(bool echo) {
+   consoleEcho = echo;
+}
+
+void setConsoleFont(const string & font) {
+   pp->setConsoleFont(font);
+}
+
+void setConsoleLogFile(const string & filename) {
+   consoleLogFile = filename;
+}
+
+void setConsolePrintExceptions(bool printExceptions) {
+    if (printExceptions && !consolePrintExceptions) {
+        old_terminate = set_terminate(sclTerminateHandler);
+    } else if (!printExceptions && consolePrintExceptions) {
+        set_terminate(old_terminate);
+    }
+    consolePrintExceptions = printExceptions;
+}
+
+void setConsoleSize(double width, double height) {
+   pp->setConsoleSize(width, height);
+}
+
+static void sclTerminateHandler() {
+   ostream& out = cerr;
+   try {
+      throw;   // re-throws the exception that already occurred
+   } catch (const ErrorException& ex) {
+      string msg = "\n ***\n";
+      msg += " *** STANFORD C++ LIBRARY \n";
+      msg += " *** An ErrorException occurred during program execution: \n";
+      msg += " *** ";
+      msg += ex.what();
+      msg += "\n ***\n\n";
+      cout.flush();
+      out << msg;
+      throw ex;
+   } catch (const std::exception& ex) {
+      string msg = "\n ***\n";
+      msg += " *** STANFORD C++ LIBRARY \n";
+      msg += " *** An exception occurred during program execution: \n";
+      msg += " *** ";
+      msg += ex.what();
+      msg += "\n ***\n\n";
+      cout.flush();
+      out << msg;
+      throw ex;
+   } catch (std::string str) {
+      string msg = "\n ***\n";
+      msg += " *** STANFORD C++ LIBRARY \n";
+      msg += " *** A string exception occurred during program execution: \n";
+      msg += " *** \"";
+      msg += str;
+      msg += "\"\n ***\n";
+      cout.flush();
+      out << msg;
+      throw str;
+   } catch (char const* str) {
+      string msg = "\n ***\n";
+      msg += " *** STANFORD C++ LIBRARY \n";
+      msg += " *** A string exception occurred during program execution: \n";
+      msg += " *** \"";
+      msg += str;
+      msg += "\"\n ***\n";
+      cout.flush();
+      out << msg;
+      throw str;
+   } catch (int n) {
+      char buf[128];
+      snprintf(buf, 128, "%d", n);
+      string msg = "\n ***\n";
+      msg += " *** STANFORD C++ LIBRARY \n";
+      msg += " *** An int exception occurred during program execution: \n";
+      msg += " *** ";
+      msg += buf;
+      msg += "\n ***\n\n";
+      cout.flush();
+      out << msg;
+      throw n;
+   } catch (long l) {
+      char buf[128];
+      snprintf(buf, 128, "%ld", l);
+      string msg = "\n ***\n";
+      msg += " *** STANFORD C++ LIBRARY \n";
+      msg += " *** A long exception occurred during program execution: \n";
+      msg += " *** ";
+      msg += buf;
+      msg += "\n ***\n\n";
+      cout.flush();
+      out << msg;
+      throw l;
+   } catch (char c) {
+      string msg = "\n ***\n";
+      msg += " *** STANFORD C++ LIBRARY \n";
+      msg += " *** A char exception occurred during program execution: \n";
+      msg += " *** '";
+      msg += c;
+      msg += "'\n ***\n";
+      cout.flush();
+      out << msg;
+      throw c;
+   } catch (bool b) {
+      string msg = "\n ***\n";
+      msg += " *** STANFORD C++ LIBRARY \n";
+      msg += " *** A bool exception occurred during program execution: \n";
+      msg += " *** ";
+      msg += (b ? "true" : "false");
+      msg += "\n ***\n\n";
+      cout.flush();
+      out << msg;
+      throw b;
+   } catch (double d) {
+      char buf[128];
+      snprintf(buf, 128, "%lf", d);
+      string msg = "\n ***\n";
+      msg += " *** STANFORD C++ LIBRARY \n";
+      msg += " *** A double exception occurred during program execution: \n";
+      msg += " *** ";
+      msg += buf;
+      msg += "\n ***\n\n";
+      cout.flush();
+      out << msg;
+      throw d;
+   }
+   abort();
+}
diff --git a/labb8/lib/StanfordCPPLib/console.h b/labb8/lib/StanfordCPPLib/console.h
new file mode 100755
index 0000000..dd3d863
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/console.h
@@ -0,0 +1,132 @@
+/*
+ * File: console.h
+ * ---------------
+ * This file redirects the <code>cin</code>, <code>cout</code>,
+ * and <code>cerr</code> channels to use a console window.  This file
+ * must be included in the source file that contains the <code>main</code>
+ * method, although it may be included in other source files as well.
+ */
+
+#ifndef _console_h
+#define _console_h
+
+#include <string>
+
+/*
+ * Function: clearConsole
+ * Usage: clearConsole();
+ * ----------------------
+ * Erases the contents of the console window.
+ */
+
+void clearConsole();
+
+/*
+ * Function: getConsoleEcho
+ * Usage: bool echo = getConsoleEcho();
+ * ----------------------------
+ * Returns whether or not the input/output from the Stanford graphical
+ * console window is being echoed onto the standard operating system terminal
+ * window. Initially this is false unless set to true by a previous call to
+ * setConsoleEcho(true).
+ */
+
+bool getConsoleEcho();
+
+/*
+ * Function: getConsoleLogFile
+ * Usage: string consoleLogFile = getConsoleLogFile();
+ * ----------------------------
+ * Returns the file name, if any, that was set by a previous call to
+ * setConsoleLogFile into which console in/output is being logged.
+ * If setConsoleLogFile has not been called yet by this program, returns
+ * an empty string ("").
+ */
+
+std::string getConsoleLogFile();
+
+/*
+ * Function: getConsolePrintExceptions
+ * Usage: bool ex = getConsolePrintExceptions();
+ * ----------------------------
+ * Returns whether or not a feature is enabled that causes exceptions to be
+ * echoed to the Stanford graphical console window when they are thrown.
+ * Disabled (false) by default.
+ */
+
+bool getConsolePrintExceptions();
+
+/*
+ * Function: setConsoleEcho
+ * Usage: setConsoleEcho(true);
+ * ----------------------------
+ * Enables or disables echoing the input/output from the Stanford graphical
+ * console window onto the standard operating system terminal window.
+ * Normally you don't need this echoing, but if you want to be able to copy
+ * and paste your console interaction into another window, it is useful.
+ */
+
+void setConsoleEcho(bool echo);
+
+/*
+ * Function: setConsoleFont
+ * Usage: setConsoleFont(font);
+ * ----------------------------
+ * Changes the font used for the console.  The <code>font</code> parameter
+ * is typically a string in the form <code>family-style-size</code>.
+ * In this string, <code>family</code> is the name of the font family;
+ * <code>style</code> is either missing (indicating a plain font) or one
+ * of the strings <code>Bold</code>, <code>Italic</code>, or
+ * <code>BoldItalic</code>; and <code>size</code> is an integer
+ * indicating the point size.  If any of these components is
+ * specified as an asterisk, the existing value is retained.
+ * The <code>font</code> parameter can also be a sequence of
+ * such specifications separated by semicolons, in which case the
+ * first available font on the system is used.
+ */
+
+void setConsoleFont(const std::string & font);
+
+/*
+ * Function: setConsoleLog
+ * Usage: setConsoleLog("myoutput.txt");
+ * ----------------------------
+ * Begins dumping a copy of all future console in/output to the given file name.
+ * Useful for capturing output logs and writing auto-grader scripts.
+ * If you are logging to a file, the output still also appears on the console.
+ * By default, logging is not initially enabled.
+ * Log text is appended to any existing content in the file as it is printed.
+ * If you pass the name of an invalid file, or one that the current user does
+ * not have permission to write, a file I/O error will occur the next time
+ * your program performs a console I/O operation to cout or cin.
+ * Set to an empty string ("") to disable logging.
+ */
+
+void setConsoleLogFile(const std::string & filename);
+
+/*
+ * Function: setConsolePrintExceptions
+ * Usage: setConsolePrintExceptions(true);
+ * ----------------------------
+ * Enables or disables a feature that causes exceptions to be echoed to the
+ * Stanford graphical console window when they are thrown.
+ * Disabled (false) by default.
+ * Note that using this feature may make it harder to get a stack trace in the
+ * debugger if you are debugging the cause of an exception.
+ */
+
+void setConsolePrintExceptions(bool printExceptions);
+
+/*
+ * Function: setConsoleSize
+ * Usage: setConsoleSize(width, height);
+ * -------------------------------------
+ * Changes the size of the console to the specified dimensions, measured
+ * in pixels.
+ */
+
+void setConsoleSize(double width, double height);
+
+#include "private/main.h"
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/direction.cpp b/labb8/lib/StanfordCPPLib/direction.cpp
new file mode 100755
index 0000000..4156d56
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/direction.cpp
@@ -0,0 +1,106 @@
+/*
+ * File: direction.cpp
+ * -------------------
+ * This file implements the direction.h interface.
+ */
+
+#include "direction.h"
+#include "error.h"
+#include "strlib.h"
+#include "tokenscanner.h"
+using namespace std;
+
+/*
+ * Implementation notes: leftFrom, rightFrom, opposite
+ * ---------------------------------------------------
+ * These functions use the remainder operator to cycle through the
+ * internal values of the enumeration type.  Note that the leftFrom
+ * function cannot subtract 1 from the direction because the result
+ * might then be negative; adding 3 achieves the same effect but
+ * ensures that the values remain positive.
+ */
+
+Direction leftFrom(Direction dir) {
+   return Direction((dir + 3) % 4);
+}
+
+Direction rightFrom(Direction dir) {
+   return Direction((dir + 1) % 4);
+}
+
+Direction opposite(Direction dir) {
+   return Direction((dir + 2) % 4);
+}
+
+/*
+ * Implementation notes: directionToString
+ * ---------------------------------------
+ * The C++ compiler requires the default clause to ensure that this
+ * function always returns a string, even if the direction is not one
+ * of the legal values.
+ */
+
+string directionToString(Direction dir) {
+   switch (dir) {
+    case NORTH: return "NORTH";
+    case EAST: return "EAST";
+    case SOUTH: return "SOUTH";
+    case WEST: return "WEST";
+    default: return "???";
+   }
+}
+
+/*
+ * Implementation notes: <<
+ * ------------------------
+ * This operator must return the stream by reference after printing
+ * the value.  The operator << returns this stream, so the function
+ * can be implemented as a single line.
+ */
+
+std::ostream & operator<<(std::ostream & os, const Direction & dir) {
+   return os << directionToString(dir);
+}
+
+/*
+ * Implementation notes: >>
+ * ------------------------
+ * This implementation uses the TokenScanner to read tokens from the
+ * stream.
+ */
+
+std::istream & operator>>(std::istream & is, Direction & dir) {
+   TokenScanner scanner(is);
+   scanner.ignoreWhitespace();
+   string token = toUpperCase(scanner.nextToken());
+   if (token == "") {
+      dir = Direction(-1);
+   } else if (startsWith("NORTH", token)) {
+      dir = NORTH;
+   } else if (startsWith("EAST", token)) {
+      dir = EAST;
+   } else if (startsWith("SOUTH", token)) {
+      dir = SOUTH;
+   } else if (startsWith("WEST", token)) {
+      dir = WEST;
+   } else {
+      error("Direction: Unrecognized direction " + token);
+   }
+   return is;
+}
+
+/*
+ * Implementation notes: ++
+ * ------------------------
+ * The int parameter in the signature for this operator is a marker used
+ * by the C++ compiler to identify the suffix form of the operator.  Note
+ * that the value after incrementing a variable containing WEST will be
+ * out of the Direction range.  That fact will not cause a problem if
+ * this operator is used only in the for loop idiom for which it is defined.
+ */
+
+Direction operator++(Direction & dir, int) {
+   Direction old = dir;
+   dir = Direction(dir + 1);
+   return old;
+}
diff --git a/labb8/lib/StanfordCPPLib/direction.h b/labb8/lib/StanfordCPPLib/direction.h
new file mode 100755
index 0000000..d858aca
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/direction.h
@@ -0,0 +1,95 @@
+/*
+ * File: direction.h
+ * -----------------
+ * This file exports an enumerated type called <code>Direction</code>
+ * whose elements are the four compass points: <code>NORTH</code>,
+ * <code>EAST</code>, <code>SOUTH</code>, and <code>WEST</code>.
+ */
+
+#ifndef _direction_h
+#define _direction_h
+
+#include <iostream>
+#include <string>
+#include "foreach.h"
+
+/*
+ * Type: Direction
+ * ---------------
+ * This enumerated type is used to represent the four compass directions.
+ */
+
+enum Direction { NORTH, EAST, SOUTH, WEST };
+
+/*
+ * Function: leftFrom
+ * Usage: Direction newdir = leftFrom(dir);
+ * ----------------------------------------
+ * Returns the direction that is to the left of the argument.
+ */
+
+Direction leftFrom(Direction dir);
+
+/*
+ * Function: rightFrom
+ * Usage: Direction newdir = rightFrom(dir);
+ * -----------------------------------------
+ * Returns the direction that is to the right of the argument.
+ */
+
+Direction rightFrom(Direction dir);
+
+/*
+ * Function: opposite
+ * Usage: Direction newdir = opposite(dir);
+ * ----------------------------------------
+ * Returns the direction that is opposite to the argument.
+ */
+
+Direction opposite(Direction dir);
+
+/*
+ * Function: directionToString
+ * Usage: string str = directionToString(dir);
+ * -------------------------------------------
+ * Returns the name of the direction as a string.
+ */
+
+std::string directionToString(Direction dir);
+
+/*
+ * Operator: <<
+ * Usage: os << dir;
+ * -----------------
+ * Overloads the <code>&lt;&lt;</code> operator so that it is able
+ * to display <code>Direction</code> values.
+ */
+
+std::ostream & operator<<(std::ostream & os, const Direction & dir);
+
+/*
+ * Operator: >>
+ * Usage: is >> dir;
+ * -----------------
+ * Overloads the <code>&gt;&gt;</code> operator so that it is able
+ * to read <code>Direction</code> values.
+ */
+
+std::istream & operator>>(std::istream & os, Direction & dir);
+
+/*
+ * Operator: ++
+ * Usage: dir++
+ * ------------
+ * Overloads the suffix version of the <code>++</code> operator to
+ * work with <code>Direction</code> values.  The sole purpose of this
+ * definition is to support the idiom
+ *
+ *<pre>
+ *    for (Direction dir = NORTH; dir &lt;= WEST; dir++) ...
+ *</pre>
+ */
+
+Direction operator++(Direction & dir, int);
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/error.cpp b/labb8/lib/StanfordCPPLib/error.cpp
new file mode 100755
index 0000000..c0e0a36
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/error.cpp
@@ -0,0 +1,42 @@
+/*
+ * File: error.cpp
+ * ---------------
+ * Implementation of the error function.
+ */
+
+#include <exception>
+#include <string>
+#include <iostream>
+#include "error.h"
+using namespace std;
+
+/* Definitions for the ErrorException class */
+
+ErrorException::ErrorException(string msg) {
+   this->msg = msg;
+}
+
+ErrorException::~ErrorException() throw () {
+   /* Empty */
+}
+
+string ErrorException::getMessage() const {
+   return msg;
+}
+
+const char *ErrorException::what() const throw () {
+   return ("Error: " + msg).c_str();
+}
+
+/*
+ * Implementation notes: error
+ * ---------------------------
+ * Earlier implementations of error made it possible, at least on the
+ * Macintosh, to help the debugger generate a backtrace at the point
+ * of the error.  Unfortunately, doing so is no longer possible if
+ * the errors are catchable.
+ */
+
+void error(string msg) {
+   throw ErrorException(msg);
+}
diff --git a/labb8/lib/StanfordCPPLib/error.h b/labb8/lib/StanfordCPPLib/error.h
new file mode 100755
index 0000000..359ea99
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/error.h
@@ -0,0 +1,56 @@
+/*
+ * File: error.h
+ * -------------
+ * This file defines the <code>ErrorException</code> class and the
+ * <code>error</code> function.
+ */
+
+#ifndef _error_h
+#define _error_h
+
+#include <string>
+#include <exception>
+
+/*
+ * Class: ErrorException
+ * ---------------------
+ * This exception is thrown by calls to the <code>error</code>
+ * function.  Typical code for catching errors looks like this:
+ *
+ *<pre>
+ *    try {
+ *       ... code in which an error might occur ...
+ *    } catch (ErrorException & ex) {
+ *       ... code to handle the error condition ...
+ *    }
+ *</pre>
+ *
+ * If an <code>ErrorException</code> is thrown at any point in the
+ * range of the <code>try</code> (including in functions called from
+ * that code), control will jump immediately to the error handler.
+ */
+
+class ErrorException : public std::exception {
+public:
+   ErrorException(std::string msg);
+   virtual ~ErrorException() throw ();
+   virtual std::string getMessage() const;
+   virtual const char *what() const throw ();
+
+private:
+   std::string msg;
+};
+
+/*
+ * Function: error
+ * Usage: error(msg);
+ * ------------------
+ * Signals an error condition in a program by throwing an
+ * <code>ErrorException</code> with the specified message.
+ */
+
+void error(std::string msg);
+
+#include "private/main.h"
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/filelib.cpp b/labb8/lib/StanfordCPPLib/filelib.cpp
new file mode 100755
index 0000000..c598db4
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/filelib.cpp
@@ -0,0 +1,360 @@
+/*
+ * File: filelib.cpp
+ * -----------------
+ * This file implements the filelib.h interface.  All platform dependencies
+ * are managed through the platform interface.
+ */
+
+#include <algorithm>
+#include <cctype>
+#include <cstdio>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+#include "filelib.h"
+#include "foreach.h"
+#include "platform.h"
+#include "strlib.h"
+#include "vector.h"
+using namespace std;
+
+static Platform *pp = getPlatform();
+
+/* Prototypes */
+
+static void splitPath(string path, Vector<string> list);
+static bool recursiveMatch(string str, int sx, string pattern, int px);
+
+/* Implementations */
+
+bool openFile(ifstream & stream, string filename) {
+   stream.clear();
+   stream.open(expandPathname(filename).c_str());
+   return !stream.fail();
+}
+
+bool openFile(ofstream & stream, string filename) {
+   stream.clear();
+   stream.open(expandPathname(filename).c_str());
+   return !stream.fail();
+}
+
+string promptUserForFile(ifstream & stream, string prompt) {
+   while (true) {
+      cout << prompt;
+      string filename;
+      getline(cin, filename);
+      openFile(stream, filename);
+      if (!stream.fail()) return filename;
+      stream.clear();
+      cout << "Unable to open that file.  Try again." << endl;
+      if (prompt == "") prompt = "Input file: ";
+   }
+}
+
+string promptUserForFile(ofstream & stream, string prompt) {
+   while (true) {
+      cout << prompt;
+      string filename;
+      getline(cin, filename);
+      openFile(stream, filename);
+      if (!stream.fail()) return filename;
+      stream.clear();
+      cout << "Unable to open that file.  Try again." << endl;
+      if (prompt == "") prompt = "Output file: ";
+   }
+}
+
+string openFileDialog(ifstream & stream) {
+   return openFileDialog(stream, "Open File", "");
+}
+
+string openFileDialog(ifstream & stream, string title) {
+   return openFileDialog(stream, title, "");
+}
+
+string openFileDialog(ifstream & stream, string title, string path) {
+   string filename = pp->openFileDialog(title, "load", path);
+   if (filename == "") return "";
+   stream.open(filename.c_str());
+   return (stream.fail()) ? "" : filename;
+}
+
+string openFileDialog(ofstream & stream) {
+   return openFileDialog(stream, "Open File", "");
+}
+
+string openFileDialog(ofstream & stream, string title) {
+   return openFileDialog(stream, title, "");
+}
+
+string openFileDialog(ofstream & stream, string title, string path) {
+   string filename = pp->openFileDialog(title, "save", path);
+   if (filename == "") return "";
+   stream.open(filename.c_str());
+   return (stream.fail()) ? "" : filename;
+}
+
+void readEntireFile(istream & is, Vector<string> & lines) {
+   lines.clear();
+   while (true) {
+      string line;
+      getline(is, line);
+      if (is.fail()) break;
+      lines.add(line);
+   }
+}
+
+void readEntireFile(istream & is, vector<string> & lines) {
+   lines.clear();
+   while (true) {
+      string line;
+      getline(is, line);
+      if (is.fail()) break;
+      lines.push_back(line);
+   }
+}
+
+string getRoot(string filename) {
+   int dot = -1;
+   int len = filename.length();
+   for (int i = 0; i < len; i++) {
+      char ch = filename[i];
+      if (ch == '.') dot = i;
+      if (ch == '/' || ch == '\\') dot = -1;
+   }
+   if (dot == -1) {
+      return filename;
+   } else {
+      return filename.substr(0, dot);
+   }
+}
+
+string getExtension(string filename) {
+   int dot = -1;
+   int len = filename.length();
+   for (int i = 0; i < len; i++) {
+      char ch = filename[i];
+      if (ch == '.') dot = i;
+      if (ch == '/' || ch == '\\') dot = -1;
+   }
+   if (dot == -1) {
+      return "";
+   } else {
+      return filename.substr(dot);
+   }
+}
+
+string getHead(string filename) {
+   int slash = -1;
+   int len = filename.length();
+   for (int i = 0; i < len; i++) {
+      char ch = filename[i];
+      if (ch == '/' || ch == '\\') slash = i;
+   }
+   if (slash < 0) {
+      return "";
+   } else if (slash == 0) {
+      return "/";
+   } else {
+      return filename.substr(0, slash);
+   }
+}
+
+string getTail(string filename) {
+   int slash = -1;
+   int len = filename.length();
+   for (int i = 0; i < len; i++) {
+      char ch = filename[i];
+      if (ch == '/' || ch == '\\') slash = i;
+   }
+   if (slash < 0) {
+      return filename;
+   } else {
+      return filename.substr(slash + 1);
+   }
+}
+
+string defaultExtension(string filename, string ext) {
+   bool force = (ext[0] == '*');
+   if (force) ext = ext.substr(1);
+   int dot = -1;
+   int len = filename.length();
+   for (int i = 0; i < len; i++) {
+      char ch = filename[i];
+      if (ch == '.') dot = i;
+      if (ch == '/' || ch == '\\') dot = -1;
+   }
+   if (dot == -1) {
+      force = true;
+      dot = len;
+   }
+   if (force) {
+      return filename.substr(0, dot) + ext;
+   } else {
+      return filename;
+   }
+}
+
+string openOnPath(ifstream & stream, string path, string filename) {
+   Vector<string> paths;
+   splitPath(path, paths);
+   foreach (string dir in paths) {
+      string pathname = dir + "/" + filename;
+      if (openFile(stream, pathname)) return pathname;
+   }
+   return "";
+}
+
+string openOnPath(ofstream & stream, string path, string filename) {
+   Vector<string> paths;
+   splitPath(path, paths);
+   foreach (string dir in paths) {
+      string pathname = dir + "/" + filename;
+      if (openFile(stream, pathname)) return pathname;
+   }
+   return "";
+}
+
+string findOnPath(string path, string filename) {
+   ifstream stream;
+   string result = openOnPath(stream, path, filename);
+   if (result != "") stream.close();
+   return result;
+}
+
+void deleteFile(string filename) {
+   remove(expandPathname(filename).c_str());
+}
+
+void renameFile(string oldname, string newname) {
+   oldname = expandPathname(oldname);
+   newname = expandPathname(newname);
+   rename(oldname.c_str(), newname.c_str());
+}
+
+void createDirectoryPath(string path) {
+   size_t cp = 1;
+   if (path == "") return;
+   while ((cp = path.find('/', cp + 1)) != string::npos) {
+      createDirectory(path.substr(0, cp - 1));
+   }
+   createDirectory(path);
+}
+
+bool matchFilenamePattern(string filename, string pattern) {
+   return recursiveMatch(filename, 0, pattern, 0);
+}
+
+bool fileExists(string filename) {
+   return pp->fileExists(filename);
+}
+
+bool isFile(string filename) {
+   return pp->isFile(filename);
+}
+
+bool isSymbolicLink(string filename) {
+   return pp->isSymbolicLink(filename);
+}
+
+bool isDirectory(string filename) {
+   return pp->isDirectory(filename);
+}
+
+void setCurrentDirectory(string path) {
+   return pp->setCurrentDirectory(path);
+}
+
+string getCurrentDirectory() {
+   return pp->getCurrentDirectory();
+}
+
+void createDirectory(string path) {
+   return pp->createDirectory(path);
+}
+
+string getDirectoryPathSeparator() {
+   return pp->getDirectoryPathSeparator();
+}
+
+string getSearchPathSeparator() {
+   return pp->getSearchPathSeparator();
+}
+
+string expandPathname(string filename) {
+   return pp->expandPathname(filename);
+}
+
+void listDirectory(string path, Vector<string> & list) {
+   vector<string> vec;
+   listDirectory(path, vec);
+   list.clear();
+   foreach (string file in vec) {
+      list.add(file);
+   }
+}
+
+void listDirectory(string path, vector<string> & list) {
+   return pp->listDirectory(path, list);
+}
+
+/* Private functions */
+
+static void splitPath(string path, Vector<string> list) {
+   char sep = (path.find(';') == string::npos) ? ':' : ';';
+   path += sep;
+   size_t start = 0;
+   while (true) {
+      size_t finish = path.find(sep, start);
+      if (finish == string::npos) break;
+      if (finish > start + 1) {
+         list.add(path.substr(start, finish - start - 1));
+      }
+      start = finish + 1;
+   }
+}
+
+static bool recursiveMatch(string str, int sx, string pattern, int px) {
+   int slen = str.length();
+   int plen = pattern.length();
+   if (px == plen) return (sx == slen);
+   char pch = pattern[px];
+   if (pch == '*') {
+      for (int i = sx; i <= slen; i++) {
+         if (recursiveMatch(str, i, pattern, px + 1)) return true;
+      }
+      return false;
+   }
+   if (sx == slen) return false;
+   char sch = str[sx];
+   if (pch == '[') {
+      bool match = false;
+      bool invert = false;
+      px++;
+      if (px == plen) {
+         error("matchFilenamePattern: missing ]");
+      }
+      if (pattern[px] == '^') {
+         px++;
+         invert = true;
+      }
+      while (px < plen && pattern[px] != ']') {
+         if (px + 2 < plen && pattern[px + 1] == '-') {
+            match |= (sch >= pattern[px] && sch <= pattern[px + 2]);
+            px += 3;
+         } else {
+            match |= (sch == pattern[px]);
+            px++;
+         }
+      }
+      if (px == plen) {
+         error("matchFilenamePattern: missing ]");
+      }
+      if (match == invert) return false;
+   } else if (pch != '?') {
+      if (pch != sch) return false;
+   }
+   return recursiveMatch(str, sx + 1, pattern, px + 1);
+}
diff --git a/labb8/lib/StanfordCPPLib/filelib.h b/labb8/lib/StanfordCPPLib/filelib.h
new file mode 100755
index 0000000..f0c90ea
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/filelib.h
@@ -0,0 +1,352 @@
+/*
+ * File: filelib.h
+ * ---------------
+ * This file exports a standardized set of tools for working with
+ * files.  The library offers at least some portability across the
+ * file systems used in the three supported platforms: Mac OSX,
+ * Windows, and Linux.  Directory and search paths are allowed to
+ * contain separators in any of the supported styles, which usually
+ * makes it possible to use the same code on different platforms.
+ */
+
+#ifndef _filelib_h
+#define _filelib_h
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+#include "vector.h"
+
+/*
+ * Function: openFile
+ * Usage: if (openFile(stream, filename)) ...
+ * ------------------------------------------
+ * Opens the filestream <code>stream</code> using the specified
+ * filename.  This function is similar to the <code>open</code>
+ * method of the stream classes, but uses a C++ <code>string</code>
+ * object instead of the older C-style string.  If the operation
+ * succeeds, <code>openFile</code> returns <code>true</code>;
+ * if it fails, <code>openFile</code> sets the failure flag in the
+ * stream and returns <code>false</code>.
+ */
+
+bool openFile(std::ifstream & stream, std::string filename);
+bool openFile(std::ofstream & stream, std::string filename);
+
+/*
+ * Function: promptUserForFile
+ * Usage: string filename = promptUserForFile(stream, prompt);
+ * -----------------------------------------------------------
+ * Asks the user for the name of a file.  The file is opened using
+ * the reference parameter <code>stream</code>, and the function
+ * returns the name of the file.  If the requested file cannot be
+ * opened, the user is given additional chances to enter a valid file.
+ * The optional <code>prompt</code> argument provides an input prompt
+ * for the user.
+ */
+
+std::string promptUserForFile(std::ifstream & stream, std::string prompt = "");
+std::string promptUserForFile(std::ofstream & stream, std::string prompt = "");
+
+/*
+ * Function: openFileDialog
+ * Usage: string filename = openFileDialog(stream);
+ *        string filename = openFileDialog(stream, title);
+ *        string filename = openFileDialog(stream, title, path);
+ * -------------------------------------------------------------
+ * Opens a dialog that allows the user to choose the file.  The
+ * <code>title</code> parameter is displayed in the dialog title.
+ * The <code>path</code> parameter is used to set the working directory;
+ * if <code>path</code> does not appear, <code>openFileDialog</code>
+ * uses the current directory.
+ */
+
+std::string openFileDialog(std::ifstream & stream);
+std::string openFileDialog(std::ifstream & stream, std::string title);
+std::string openFileDialog(std::ifstream & stream, std::string title,
+                                                   std::string path);
+std::string openFileDialog(std::ofstream & stream);
+std::string openFileDialog(std::ofstream & stream, std::string title);
+std::string openFileDialog(std::ofstream & stream, std::string title,
+                                                   std::string path);
+
+/*
+ * Function: readEntireFile
+ * Usage: readEntireFile(is, lines);
+ * ---------------------------------
+ * Reads the entire contents of the specified input stream into the
+ * string vector <code>lines</code>.  The client is responsible for
+ * opening and closing the stream.  The vector can be either an STL
+ * <code>vector</code> or a <code>Vector</code> as defined in the
+ * Stanford C++ libraries.
+ */
+
+void readEntireFile(std::istream & is, Vector<std::string> & lines);
+void readEntireFile(std::istream & is, std::vector<std::string> & lines);
+
+/*
+ * Function: getRoot
+ * Usage: string root = getRoot(filename);
+ * ---------------------------------------
+ * Returns the root of <code>filename</code>.  The root consists
+ * of everything in <code>filename</code> up to the last dot and
+ * the subsequent extension.  If no dot appears in the final component
+ * of the filename, <code>getRoot</code> returns the entire name.
+ */
+
+std::string getRoot(std::string filename);
+
+/*
+ * Function: getExtension
+ * Usage: ext = getExtension(filename);
+ * ------------------------------------
+ * Returns the extension of <code>filename</code>.  The extension
+ * consists of the separating dot and all subsequent characters.
+ * If no dot exists in the final component, <code>getExtension</code>
+ * returns the empty string.  These semantics ensure that concatenating
+ * the root and the extension always returns the original filename.
+ */
+
+std::string getExtension(std::string filename);
+
+/*
+ * Function: getHead
+ * Usage: head = getHead(filename);
+ * --------------------------------
+ * Returns all but the last component of a path name.  The components
+ * of the path name can be separated by any of the directory path
+ * separators (forward or reverse slashes).  The special cases are
+ * illustrated by the following examples:
+ *
+ *<pre>
+ *    getHead("a/b")  = "a"     getTail("a/b")   = "b"
+ *    getHead("a")    = ""      getTail("a")     = "a"
+ *    getHead("/a")   = "/"     getTail("/a")    = "a"
+ *    getHead("/")    = "/"     getTail("/")     = ""
+ *</pre>
+ */
+
+std::string getHead(std::string filename);
+
+/*
+ * Function: getTail
+ * Usage: tail = getTail(filename);
+ * --------------------------------
+ * Returns the last component of a path name.  The components of the
+ * path name can be separated by any of the directory path separators
+ * (forward or reverse slashes).  For details on the interpretation of
+ * special cases, see the comments for the <code>getHead</code> function.
+ */
+
+std::string getTail(std::string filename);
+
+/*
+ * Function: defaultExtension
+ * Usage: string newname = defaultExtension(filename, ext);
+ * --------------------------------------------------------
+ * Adds an extension to a file name if none already exists.  If the
+ * <code>extension</code> argument begins with a leading <code>*</code>,
+ * any existing extension in <code>filename</code> is replaced by
+ * <code>ext</code>.
+ */
+
+std::string defaultExtension(std::string filename, std::string ext);
+
+/*
+ * Function: openOnPath
+ * Usage: string pathname = openOnPath(stream, path, filename);
+ * ------------------------------------------------------------
+ * Opens a file using a search path.  If <code>openOnPath</code>
+ * is successful, it returns the first path name on the search path
+ * for which <code>stream.open</code> succeeds.  The <code>path</code>
+ * argument consists of a list of directories that are prepended to the
+ * filename, unless <code>filename</code> begins with an absolute
+ * directory marker, such as <code>/</code> or <code>~</code>.
+ * The directories in the search path may be separated either
+ * by colons (Unix or Mac OS) or semicolons (Windows).  If the file
+ * cannot be opened, the failure bit is set in the <code>stream</code>
+ * parameter, and the <code>openOnPath</code> function returns the
+ * empty string.
+ */
+
+std::string openOnPath(std::ifstream & stream, std::string path,
+                                               std::string filename);
+std::string openOnPath(std::ofstream & stream, std::string path,
+                                               std::string filename);
+
+/*
+ * Function: findOnPath
+ * Usage: string pathname = findOnPath(path, filename);
+ * ----------------------------------------------------
+ * Returns the canonical name of a file found using a search path.
+ * The <code>findOnPath</code> function is similar to
+ * <code>openOnPath</code>, except that it doesn't actually
+ * return an open stream.  If no matching file is found,
+ * <code>findOnPath</code> returns the empty string.
+ */
+
+std::string findOnPath(std::string path, std::string filename);
+
+/*
+ * Function: deleteFile
+ * Usage: deleteFile(filename);
+ * ----------------------------
+ * Deletes the specified file.  Errors are reported by calling
+ * <code>error</code>.
+ */
+
+void deleteFile(std::string filename);
+
+/*
+ * Function: renameFile
+ * Usage: renameFile(oldname, newname);
+ * ------------------------------------
+ * Renames a file.  Errors are reported by calling
+ * <code>error</code> in the implementation.
+ */
+
+void renameFile(std::string oldname, std::string newname);
+
+/*
+ * Function: fileExists
+ * Usage: if (fileExists(filename)) ...
+ * ------------------------------------
+ * Returns <code>true</code> if the specified file exists.
+ */
+
+bool fileExists(std::string filename);
+
+/*
+ * Function: isFile
+ * Usage: if (isFile(filename)) ...
+ * --------------------------------
+ * Returns <code>true</code> if the specified file is a regular file.
+ */
+
+bool isFile(std::string filename);
+
+/*
+ * Function: isSymbolicLink
+ * Usage: if (isSymbolicLink(filename)) ...
+ * ----------------------------------------
+ * Returns <code>true</code> if the specified file is a symbolic link.
+ */
+
+bool isSymbolicLink(std::string filename);
+
+/*
+ * Function: isDirectory
+ * Usage: if (isDirectory(filename)) ...
+ * -------------------------------------
+ * Returns <code>true</code> if the specified file is a directory.
+ */
+
+bool isDirectory(std::string filename);
+
+/*
+ * Function: setCurrentDirectory
+ * Usage: setCurrentDirectory(filename);
+ * -------------------------------------
+ * Changes the current directory to the specified path.
+ */
+
+void setCurrentDirectory(std::string path);
+
+/*
+ * Function: getCurrentDirectory
+ * Usage: string filename = getCurrentDirectory();
+ * -----------------------------------------------
+ * Returns an absolute filename for the current directory.
+ */
+
+std::string getCurrentDirectory();
+
+/*
+ * Function: createDirectory
+ * Usage: createDirectory(path);
+ * -----------------------------
+ * Creates a new directory for the specified path.  The
+ * <code>createDirectory</code> function does not report an error if
+ * the directory already exists.  Unlike <code>createDirectoryPath</code>,
+ * <code>createDirectory</code> does not create missing directories
+ * along the path.  If some component of <code>path</code> does
+ * not exist, this function signals an error.
+ */
+
+void createDirectory(std::string path);
+
+/*
+ * Function: createDirectoryPath
+ * Usage: createDirectoryPath(path);
+ * ---------------------------------
+ * Creates a new directory for the specified path.   If intermediate
+ * components of <code>path</code> do not exist, this function creates
+ * them as needed.
+ */
+
+void createDirectoryPath(std::string path);
+
+/*
+ * Function: expandPathname
+ * Usage: string pathname = expandPathname(filename);
+ * --------------------------------------------------
+ * Expands a filename into a canonical name for the platform.
+ */
+
+std::string expandPathname(std::string filename);
+
+/*
+ * Function: listDirectory
+ * Usage: listDirectory(path, list);
+ * ---------------------------------
+ * Adds an alphabetized list of the files in the specified directory
+ * to the string vector <code>list</code>.  This list excludes the
+ * names <code>.</code> and <code>..</code> entries.
+ */
+
+void listDirectory(std::string path, Vector<std::string> & list);
+void listDirectory(std::string path, std::vector<std::string> & list);
+
+/*
+ * Function: matchFilenamePattern
+ * Usage: if (matchFilenamePattern(filename, pattern)) ...
+ * -------------------------------------------------------
+ * Determines whether the filename matches the specified pattern.  The
+ * pattern string is interpreted in much the same way that a Unix shell
+ * expands filenames and supports the following wildcard options:
+ *
+ *<pre>
+ *    ?      Matches any single character
+ *    *      Matches any sequence of characters
+ *    [...]  Matches any of the specified characters
+ *    [^...] Matches any character <i>except</i> the specified ones
+ *</pre>
+ *
+ * The last two options allow a range of characters to be specified in the
+ * form <code>a-z</code>.
+ */
+
+bool matchFilenamePattern(std::string filename, std::string pattern);
+
+/*
+ * Function: getDirectoryPathSeparator
+ * Usage: string sep = getDirectoryPathSeparator();
+ * ------------------------------------------------
+ * Returns the standard directory path separator used on this platform.
+ */
+
+std::string getDirectoryPathSeparator();
+
+/*
+ * Function: getSearchPathSeparator
+ * Usage: string sep = getSearchPathSeparator();
+ * ---------------------------------------------
+ * Returns the standard search path separator used on this platform.
+ */
+
+std::string getSearchPathSeparator();
+
+#include "private/main.h"
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/foreach.h b/labb8/lib/StanfordCPPLib/foreach.h
new file mode 100755
index 0000000..15a758b
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/foreach.h
@@ -0,0 +1,217 @@
+/*
+ * File: foreach.h
+ * ---------------
+ * This file defines the <code>foreach</code> keyword, which implements
+ * a substitute for the range-based <code>for</code> loop from C++11.
+ * All iterable classes in the Stanford libraries import this file, so
+ * clients don't ordinarily need to do so explicitly.  This version of
+ * <code>foreach</code> also supports C++ strings and arrays.
+ */
+
+#ifndef _foreach_h
+#define _foreach_h
+
+/*
+ * Statement: foreach
+ * Usage: foreach (type var in collection) { ... }
+ * -----------------------------------------------
+ * The <code>foreach</code> statement steps through the elements in
+ * a collection.  It works correctly with the collection classes in
+ * both the Standard Template Library and the Stanford C++ libraries,
+ * but can also be used with C++ strings and statically initialized
+ * arrays.
+ *
+ * <p>The following code, for example, prints every element in the
+ * string vector <code>lines</code>:
+ *
+ *<pre>
+ *    foreach (string str in lines) {
+ *       cout &lt;&lt; str &lt;&lt; endl;
+ *    }
+ *</pre>
+ *
+ * Similarly, the following function calculates the sum of the character
+ * codes in a string:
+ *
+ *<pre>
+ *    int sumCharacterCodes(string str) {
+ *       int sum = 0;
+ *       foreach (char ch in str) sum += ch;
+ *       return sum;
+ *    }
+ *</pre>
+ *
+ * As a simplification when iterating over maps, the <code>foreach</code>
+ * macro iterates through the keys rather than the key/value pairs.
+ */
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in the file is logically part    */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+#include <iterator>
+#include <map>
+#include <cstddef>
+#include <cstring>
+
+/* These #includes are for files that contain "in" as a token */
+
+#include <ios>
+#include <fstream>
+#include <sstream>
+using namespace std;
+
+/* Redefine the ios constants (one of which is "in") */
+
+static const ios::openmode IOS_APP = ios::app;
+static const ios::openmode IOS_ATE = ios::ate;
+static const ios::openmode IOS_BINARY = ios::binary;
+static const ios::openmode IOS_IN = ios::in;
+static const ios::openmode IOS_OUT = ios::out;
+static const ios::openmode IOS_TRUNC = ios::trunc;
+
+/* Private implementation namespace */
+
+namespace _fe {
+   struct Range {
+      virtual ~Range() { };
+   };
+
+   template <typename T>
+   struct ArrayRange : Range {
+      ArrayRange(const T *begin, const T *end) : iter(begin), end(end) { }
+      const T *iter;
+      const T *end;
+   };
+
+   template <typename CType>
+   struct CRange : Range {
+      CRange(const CType& c) :
+         cont(c), iter(cont.begin()), end(cont.end()) { }
+      CType cont;
+      typename CType::iterator iter, end;
+   };
+
+   template <typename KT, typename VT, typename CT, typename AT>
+   struct MapRange : Range {
+      MapRange(const map<KT,VT,CT,AT> & c) :
+         cont(c), iter(cont.begin()), end(cont.end()) { }
+      map<KT,VT,CT,AT> cont;
+      typename map<KT,VT,CT,AT>::iterator iter, end;
+   };
+
+/*
+ * The State struct glues together all of these pieces and
+ * stores all of the information throughout the loops.
+ */
+
+   struct State {
+      State() : state(0), itr(NULL) { }
+      ~State() { delete itr; }
+      int state;
+      Range *itr;
+   };
+
+/* General hook function */
+
+   template <typename DowncastType, typename ValueType>
+   ValueType HookImpl(State& fe) {
+      DowncastType *ip = (DowncastType *) fe.itr;
+      if (ip->iter == ip->end) {
+         fe.state = 2;
+         return ValueType();
+      }
+      fe.state = 1;
+      ValueType vp = *ip->iter;     /* Subtle implementation note:    */
+      ++ip->iter;                   /* Using *ip->iter++ here would   */
+      return vp;                    /* require copying the iterator.  */
+   }
+
+/* Foreach implementation for containers */
+
+   template <typename CType>
+   CRange<CType> *Init(State & fe, const CType & collection) {
+      fe.itr = new CRange<CType>(collection);
+      return (CRange<CType>*) fe.itr;
+   }
+
+   template <typename CType>
+   typename iterator_traits<typename CType::iterator>::value_type
+   Hook(State & fe, CRange<CType> *) {
+      return HookImpl<CRange<CType>,
+         typename iterator_traits<typename CType::iterator>::value_type>(fe);
+   }
+
+/* For maps */
+
+   template <typename K, typename V, typename C, typename A>
+   MapRange<K,V,C,A> *Init(State & fe, const map<K,V,C,A> & collection) {
+      fe.itr = new MapRange<K,V,C,A>(collection);
+      return (MapRange<K,V,C,A>*) fe.itr;
+   }
+
+   template <typename DowncastType, typename ValueType>
+   ValueType MapHookImpl(State & fe) {
+      DowncastType *ip = (DowncastType *) fe.itr;
+      if (ip->iter == ip->end) {
+         fe.state = 2;
+         return ValueType();
+      }
+      fe.state = 1;
+      ValueType key = ip->iter->first;
+      ++ip->iter;
+      return key;
+   }
+
+   template <typename K, typename V, typename C, typename A>
+   K Hook(State & fe, MapRange<K,V,C,A> *) {
+      return MapHookImpl<MapRange<K,V,C,A>,K>(fe);
+   }
+
+/* For C strings */
+
+   template <size_t n>
+   ArrayRange<char> *Init(State & fe, char (&str)[n]) {
+      fe.itr = new ArrayRange<char>(str, str + strlen(str));
+      return (ArrayRange<char>*) fe.itr;
+   }
+
+   template <size_t n>
+   ArrayRange<char> *Init(State & fe, const char (&str)[n]) {
+      fe.itr = new ArrayRange<char>(str, str + strlen(str));
+      return (ArrayRange<char>*) fe.itr;
+   }
+
+/* For arrays */
+
+   template <typename T, size_t n>
+   ArrayRange<T> *Init(State & fe, T (&arr)[n]) {
+      fe.itr = new ArrayRange<T>(arr, arr + n);
+      return (ArrayRange<T>*) fe.itr;
+   }
+
+   template <typename T, size_t n>
+   ArrayRange<T> *Init(State & fe, const T (&arr)[n]) {
+      fe.itr = new ArrayRange<T>(arr, arr + n);
+      return (ArrayRange<T>*) fe.itr;
+   }
+
+   template <typename T>
+   T Hook(State& fe, ArrayRange<T>*) {
+      return HookImpl<ArrayRange<T>, T>(fe);
+   }
+
+}
+
+/* The actual foreach and in macros */
+
+#define foreach(arg) \
+   for (_fe::State _fe; _fe.state < 2; ) \
+      for (arg)); _fe.state++ == 1; _fe.state = 0)
+
+#define in = _fe::Hook(_fe, _fe.state != 0 ? NULL : _fe::Init(_fe,
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/gevents.cpp b/labb8/lib/StanfordCPPLib/gevents.cpp
new file mode 100755
index 0000000..72043d6
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/gevents.cpp
@@ -0,0 +1,335 @@
+/*
+ * File: gevents.cpp
+ * -----------------
+ * This file implements the machine-independent functions for the classes
+ * in the gevents.h interface.  The actual functions for receiving events
+ * from the environment are implemented in the platform package.
+ */
+
+/*
+ * Implementation notes:
+ * ---------------------
+ * The classes in this hierarchy are defined in an unusual way
+ * for C++ in that all instance variables are part of the top-level
+ * class.  The advantage of this design is that the GEvent class
+ * then has all of the memory it needs to store an event of any of
+ * its subclasses.
+ */
+
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <cctype>
+#include "error.h"
+#include "gevents.h"
+#include "gtimer.h"
+#include "gtypes.h"
+#include "map.h"
+#include "platform.h"
+using namespace std;
+
+/* Global variables */
+
+static Platform *pp = getPlatform();
+
+/* Implementation of GEvent class */
+
+GEvent::GEvent() {
+   eventClass = NULL_EVENT;
+   eventType = 0;
+   valid = false;
+   modifiers = 0;
+}
+
+EventClassType GEvent::getEventClass() const {
+   return eventClass;
+}
+
+EventType GEvent::getEventType() const {
+   return EventType(eventType);
+}
+
+double GEvent::getEventTime() const {
+   return eventTime;
+}
+
+int GEvent::getModifiers() const {
+   return modifiers;
+}
+
+string GEvent::toString() const {
+   if (eventClass == 0) {
+      return "GEvent(NULL)";
+   } else if (eventClass == WINDOW_EVENT) {
+      GWindowEvent windowEvent(*this);
+      return (&windowEvent)->toString();
+   } else if (eventClass == ACTION_EVENT) {
+      GActionEvent actionEvent(*this);
+      return (&actionEvent)->toString();
+   } else if (eventClass == MOUSE_EVENT) {
+      GMouseEvent mouseEvent(*this);
+      return (&mouseEvent)->toString();
+   } else if (eventClass == KEY_EVENT) {
+      GKeyEvent keyEvent(*this);
+      return (&keyEvent)->toString();
+   } else if (eventClass == TIMER_EVENT) {
+      GTimerEvent timerEvent(*this);
+      return (&timerEvent)->toString();
+   } else {
+      return "GEvent(?)";
+   }
+}
+
+bool GEvent::isValid() {
+   return valid;
+}
+
+void GEvent::setEventTime(double time) {
+   eventTime = time;
+}
+
+void GEvent::setModifiers(int modifiers) {
+   this->modifiers = modifiers;
+}
+
+GWindowEvent::GWindowEvent() {
+   valid = false;
+}
+
+GWindowEvent::GWindowEvent(GEvent e) {
+   valid = e.valid && e.eventClass == WINDOW_EVENT;
+   if (valid) {
+      eventClass = e.eventClass;
+      eventType = e.eventType;
+      modifiers = e.modifiers;
+      eventTime = e.eventTime;
+      gwd = e.gwd;
+   }
+}
+
+GWindowEvent::GWindowEvent(EventType type, const GWindow & gw) {
+   this->eventClass = WINDOW_EVENT;
+   this->eventType = int(type);
+   this->gwd = gw.gwd;
+   valid = true;
+}
+
+GWindow GWindowEvent::getGWindow() const {
+   return GWindow(gwd);
+}
+
+string GWindowEvent::toString() const {
+   if (!valid) return "GWindowEvent(?)";
+   ostringstream os;
+   os << "GWindowEvent:";
+   switch (eventType) {
+    case WINDOW_CLOSED:      os << "WINDOW_CLOSED";       break;
+    case WINDOW_RESIZED:     os << "WINDOW_RESIZED";      break;
+   }
+   os << "()";
+   return os.str();
+}
+
+GActionEvent::GActionEvent() {
+   valid = false;
+}
+
+GActionEvent::GActionEvent(GEvent e) {
+   valid = e.valid && e.eventClass == ACTION_EVENT;
+   if (valid) {
+      eventClass = e.eventClass;
+      eventType = e.eventType;
+      modifiers = e.modifiers;
+      eventTime = e.eventTime;
+      source = e.source;
+      actionCommand = e.actionCommand;
+   }
+}
+
+GActionEvent::GActionEvent(EventType type, GObject *source,
+                           string actionCommand) {
+   this->eventClass = ACTION_EVENT;
+   this->eventType = int(type);
+   this->source = source;
+   this->actionCommand = actionCommand;
+   valid = true;
+}
+
+GObject *GActionEvent::getSource() const {
+   return source;
+}
+
+string GActionEvent::getActionCommand() const {
+   if (!valid) error("getActionCommand: Event is not valid");
+   return actionCommand;
+}
+
+string GActionEvent::toString() const {
+   if (!valid) return "GActionEvent(?)";
+   ostringstream os;
+   os << "GActionEvent:ACTION_PERFORMED(" << actionCommand << ")";
+   return os.str();
+}
+
+GMouseEvent::GMouseEvent() {
+   valid = false;
+}
+
+GMouseEvent::GMouseEvent(GEvent e) {
+   valid = e.valid && e.eventClass == MOUSE_EVENT;
+   if (valid) {
+      eventClass = e.eventClass;
+      eventType = e.eventType;
+      modifiers = e.modifiers;
+      eventTime = e.eventTime;
+      x = e.x;
+      y = e.y;
+   }
+}
+
+GMouseEvent::GMouseEvent(EventType type, const GWindow & gw,
+                                         double x, double y) {
+   this->eventClass = MOUSE_EVENT;
+   this->eventType = int(type);
+   this->gwd = gw.gwd;
+   this->x = x;
+   this->y = y;
+   valid = true;
+}
+
+GWindow GMouseEvent::getGWindow() const {
+   return GWindow(gwd);
+}
+
+double GMouseEvent::getX() const {
+   if (!valid) error("getX: Event is not valid");
+   return x;
+}
+
+double GMouseEvent::getY() const {
+   if (!valid) error("getY: Event is not valid");
+   return y;
+}
+
+string GMouseEvent::toString() const {
+   if (!valid) return "GMouseEvent(?)";
+   ostringstream os;
+   os << "GMouseEvent:";
+   switch (eventType) {
+    case MOUSE_PRESSED:  os << "MOUSE_PRESSED";   break;
+    case MOUSE_RELEASED: os << "MOUSE_RELEASED";  break;
+    case MOUSE_CLICKED:  os << "MOUSE_CLICKED";   break;
+    case MOUSE_MOVED:    os << "MOUSE_MOVED";     break;
+    case MOUSE_DRAGGED:  os << "MOUSE_DRAGGED";   break;
+   }
+   os << "(" << x << ", " << y << ")";
+   return os.str();
+}
+
+GKeyEvent::GKeyEvent() {
+   valid = false;
+}
+
+GKeyEvent::GKeyEvent(GEvent e) {
+   this->eventClass = KEY_EVENT;
+   valid = e.valid && e.eventClass == KEY_EVENT;
+   if (valid) {
+      eventClass = e.eventClass;
+      eventType = e.eventType;
+      modifiers = e.modifiers;
+      eventTime = e.eventTime;
+      keyChar = e.keyChar;
+      keyCode = e.keyCode;
+   }
+}
+
+GKeyEvent::GKeyEvent(EventType type, const GWindow & gw,
+                                     int keyChar, int keyCode) {
+   this->eventClass = KEY_EVENT;
+   this->eventType = int(type);
+   this->gwd = gw.gwd;
+   this->keyChar = keyChar;
+   this->keyCode = keyCode;
+   valid = true;
+}
+
+GWindow GKeyEvent::getGWindow() const {
+   return GWindow(gwd);
+}
+
+char GKeyEvent::getKeyChar() const {
+   if (!valid) error("getKey: Event is not valid");
+   return char(keyChar);
+   // Think about wide characters at some point
+}
+
+int GKeyEvent::getKeyCode() const {
+   if (!valid) error("getKey: Event is not valid");
+   return keyCode;
+}
+
+string GKeyEvent::toString() const {
+   if (!valid) return "GKeyEvent(?)";
+   ostringstream os;
+   os << "GKeyEvent:";
+   int ch = '\0';
+   switch (eventType) {
+    case KEY_PRESSED:  os << "KEY_PRESSED";   ch = keyCode; break;
+    case KEY_RELEASED: os << "KEY_RELEASED";  ch = keyCode; break;
+    case KEY_TYPED:    os << "KEY_TYPED";     ch = keyChar; break;
+   }
+   if (isprint(ch)) {
+      os << "('" << char(ch) << "')";
+   } else {
+      os << oct << "('\\" << ch << "')";
+   }
+   return os.str();
+}
+
+/* Timer events */
+
+GTimerEvent::GTimerEvent() {
+   valid = false;
+}
+
+GTimerEvent::GTimerEvent(GEvent e) {
+   valid = e.valid && e.eventClass == TIMER_EVENT;
+   if (valid) {
+      eventClass = e.eventClass;
+      eventType = e.eventType;
+      modifiers = e.modifiers;
+      eventTime = e.eventTime;
+      gtd = e.gtd;
+   }
+}
+
+GTimerEvent::GTimerEvent(EventType type, const GTimer & timer) {
+   this->eventClass = TIMER_EVENT;
+   this->eventType = int(type);
+   this->gtd = timer.gtd;
+   valid = true;
+}
+
+GTimer GTimerEvent::getGTimer() const {
+   return GTimer(gtd);
+}
+
+string GTimerEvent::toString() const {
+   if (!valid) return "GTimerEvent(?)";
+   return "GTimerEvent:TIMER_TICKED()";
+}
+
+/* Global event handlers */
+
+void waitForClick() {
+   waitForEvent(CLICK_EVENT);
+}
+
+GEvent waitForEvent(int mask) {
+   return pp->waitForEvent(mask);
+}
+
+GEvent getNextEvent(int mask) {
+   return pp->getNextEvent(mask);
+}
+
diff --git a/labb8/lib/StanfordCPPLib/gevents.h b/labb8/lib/StanfordCPPLib/gevents.h
new file mode 100755
index 0000000..49717f9
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/gevents.h
@@ -0,0 +1,734 @@
+/*
+ * File: gevents.h
+ * ---------------
+ * This file defines the event types used in the StanfordCPPLib
+ * graphics libraries.  The structure of this package is adapted from
+ * the Java event model.
+ * <include src="pictures/ClassHierarchies/GEventHierarchy-h.html">
+ */
+
+#ifndef _gevents_h
+#define _gevents_h
+
+#include <string>
+#include "gtimer.h"
+#include "gwindow.h"
+
+/*
+ * Type: EventClassType
+ * --------------------
+ * This enumeration type defines the event classes.  The element values
+ * are each a single bit and can be added or ORed together to generate
+ * an event mask.  The <code>CLICK_EVENT</code> class responds only to
+ * the MOUSE_CLICKED event type.  The <code>ANY_EVENT</code> class
+ * selects any event.
+ */
+
+enum EventClassType {
+   NULL_EVENT   = 0x000,
+   ACTION_EVENT = 0x010,
+   KEY_EVENT    = 0x020,
+   TIMER_EVENT  = 0x040,
+   WINDOW_EVENT = 0x080,
+   MOUSE_EVENT  = 0x100,
+   CLICK_EVENT  = 0x200,
+   ANY_EVENT    = 0x3F0
+};
+
+/*
+ * Type: EventType
+ * ---------------
+ * This enumeration type defines the event types for all events.
+ */
+
+typedef enum {
+   WINDOW_CLOSED    = WINDOW_EVENT + 1,
+   WINDOW_RESIZED   = WINDOW_EVENT + 2,
+   ACTION_PERFORMED = ACTION_EVENT + 1,
+   MOUSE_CLICKED    = MOUSE_EVENT + 1,
+   MOUSE_PRESSED    = MOUSE_EVENT + 2,
+   MOUSE_RELEASED   = MOUSE_EVENT + 3,
+   MOUSE_MOVED      = MOUSE_EVENT + 4,
+   MOUSE_DRAGGED    = MOUSE_EVENT + 5,
+   KEY_PRESSED      = KEY_EVENT + 1,
+   KEY_RELEASED     = KEY_EVENT + 2,
+   KEY_TYPED        = KEY_EVENT + 3,
+   TIMER_TICKED     = TIMER_EVENT + 1,
+} EventType;
+
+/*
+ * Type: ModifierCodes
+ * -------------------
+ * This enumeration type defines a set of constants used to check whether
+ * modifiers are in effect.
+ */
+
+enum ModifierCodes {
+   SHIFT_DOWN     = 1 << 0,
+   CTRL_DOWN      = 1 << 1,
+   META_DOWN      = 1 << 2,
+   ALT_DOWN       = 1 << 3,
+   ALT_GRAPH_DOWN = 1 << 4,
+   BUTTON1_DOWN   = 1 << 5,
+   BUTTON2_DOWN   = 1 << 6,
+   BUTTON3_DOWN   = 1 << 7
+};
+
+/*
+ * Type: KeyCodes
+ * --------------
+ * This type defines the names of the key codes returned in a key event.
+ */
+
+enum KeyCodes {
+   BACKSPACE_KEY = 8,
+   TAB_KEY = 9,
+   ENTER_KEY = 10,
+   CLEAR_KEY = 12,
+   ESCAPE_KEY = 27,
+   PAGE_UP_KEY = 33,
+   PAGE_DOWN_KEY = 34,
+   END_KEY = 35,
+   HOME_KEY = 36,
+   LEFT_ARROW_KEY = 37,
+   UP_ARROW_KEY = 38,
+   RIGHT_ARROW_KEY = 39,
+   DOWN_ARROW_KEY = 40,
+   F1_KEY = 112,
+   F2_KEY = 113,
+   F3_KEY = 114,
+   F4_KEY = 115,
+   F5_KEY = 116,
+   F6_KEY = 117,
+   F7_KEY = 118,
+   F8_KEY = 119,
+   F9_KEY = 120,
+   F10_KEY = 121,
+   F11_KEY = 122,
+   F12_KEY = 123,
+   DELETE_KEY = 127,
+   HELP_KEY = 156
+};
+
+/* Forward definitions */
+
+class GWindowEvent;
+class GActionEvent;
+class GMouseEvent;
+class GKeyEvent;
+class GTimerEvent;
+class GObject;
+
+/*
+ * Class: GEvent
+ * -------------
+ * This class is the root of the hierarchy for all events.
+ * <include src="pictures/ClassHierarchies/GEventHierarchy.html">
+ *
+ * <p>The standard paradigm for using <code>GEvent</code> is illustrated
+ * by the following program, which allows the user to draw lines on the
+ * graphics window:
+ *
+ *<pre>
+ *    int main() {
+ *       GWindow gw;
+ *       GLine *line;
+ *       cout << "This program lets the user draw lines by dragging." << endl;
+ *       while (true) {
+ *          GMouseEvent e = waitForEvent(MOUSE_EVENT);
+ *          if (e.getEventType() == MOUSE_PRESSED) {
+ *             line = new GLine(e.getX(), e.getY(), e.getX(), e.getY());
+ *             gw.add(line);
+ *          } else if (e.getEventType() == MOUSE_DRAGGED) {
+ *             line->setEndPoint(e.getX(), e.getY());
+ *          }
+ *       }
+ *    }
+ *</pre>
+ */
+
+class GEvent {
+
+public:
+
+/*
+ * Friend constructor: GEvent
+ * Usage: GEvent event;
+ * --------------------
+ * Ensures that an event is properly initialized to a <code>NULL</code> event.
+ */
+
+   GEvent();
+
+/*
+ * Method: getEventClass
+ * Usage: EventClassType eventClass = e.getEventClass();
+ * -----------------------------------------------------
+ * Returns the enumerated type constant indicating the class of the
+ * event.
+ */
+
+   EventClassType getEventClass() const;
+
+/*
+ * Method: getEventType
+ * Usage: EventType type = e.getEventType();
+ * -----------------------------------------
+ * Returns the enumerated type constant corresponding to the specific
+ * event type.
+ */
+
+   EventType getEventType() const;
+
+/*
+ * Method: getEventTime
+ * Usage: double time = e.getEventTime();
+ * --------------------------------------
+ * Returns the system time in milliseconds at which the event occurred.
+ * To ensure portability among systems that represent time in different
+ * ways, the StanfordCPPLib packages use type <code>double</code> to
+ * represent time, which is always encoded as the number of milliseconds
+ * that have elapsed since 00:00:00 UTC on January 1, 1970, which is
+ * the conventional zero point for computer-based time systems.
+ */
+
+   double getEventTime() const;
+
+/*
+ * Method: getModifiers
+ * Usage: int modifiers = e.getModifiers();
+ * ----------------------------------------
+ * Returns an integer whose bits indicate what modifiers are in effect.
+ * To check whether the shift key is down, for example, one could use
+ * the following code:
+ *
+ *<pre>
+ *    if (e.getModifiers() & SHIFT_DOWN) ...
+ *</pre>
+ */
+
+   int getModifiers() const;
+
+/*
+ * Method: toString
+ * Usage: string str = e.toString();
+ * ---------------------------------
+ * Converts the event to a human-readable representation of the event.
+ */
+
+   virtual std::string toString() const;
+
+/*
+ * Method: isValid
+ * Usage: if (e.isValid()) ...
+ * ---------------------------
+ * Returns <code>true</code> if the event is valid.
+ */
+
+   bool isValid();
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in the file is logically part    */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+/*
+ * Method: setEventTime
+ * Usage: e.setEventTime(time);
+ * ----------------------------
+ * Sets the event time field for this event.  The event system needs
+ * access to this method, but conventional clients don't.
+ */
+
+   void setEventTime(double time);
+
+/*
+ * Method: setModifiers
+ * Usage: e.setModifiers(modifiers);
+ * ---------------------------------
+ * Sets the modifiers field for this event.  The event system needs
+ * access to this method, but conventional clients don't.
+ */
+
+   void setModifiers(int modifiers);
+
+private:
+
+/*
+ * Instance variables
+ * ------------------
+ * Implementation note: All the variables from the subclasses are included
+ * in the outer class to make it possible to convert between general events
+ * and the various subclasses.  By keeping all event classes the same size,
+ * this design avoids any issues of slicing off parts of the data during
+ * such conversions.
+ */
+
+/* General events */
+
+   EventClassType eventClass;
+   int eventType;
+   int modifiers;
+   double eventTime;
+   bool valid;
+   std::string sourceKey;
+
+/* Window, mouse, and key events */
+
+   GWindowData *gwd;
+
+/* Action events */
+
+   GObject *source;
+   std::string actionCommand;
+
+/* Mouse events */
+
+   double x;
+   double y;
+
+/* Key events */
+
+   int keyChar;
+   int keyCode;
+
+/* Timer events */
+
+   GTimerData *gtd;
+
+/* Friend specifications */
+
+friend class GWindowEvent;
+friend class GActionEvent;
+friend class GMouseEvent;
+friend class GKeyEvent;
+friend class GTimerEvent;
+
+};
+
+/*
+ * Function: waitForClick
+ * Usage: waitForClick();
+ * ----------------------
+ * Waits for a mouse click in any window, discarding any other events.
+ */
+
+void waitForClick();
+
+/*
+ * Function: waitForEvent
+ * Usage: GEvent e = waitForEvent(mask);
+ * -------------------------------------
+ * Dismisses the process until an event occurs whose type is covered by
+ * the event mask.  The mask parameter is a combination of the events of
+ * interest.  For example, to wait for a mouse event or an action event,
+ * clients can use the following call:
+ *
+ *<pre>
+ *    e = waitForEvent(MOUSE_EVENT + ACTION_EVENT);
+ *</pre>
+ *
+ * The <code>mask</code> parameter is optional.  If it is missing,
+ * <code>waitForEvent</code> accepts any event.
+ *
+ * <p>As a more sophisticated example, the following code is the canonical
+ * event loop for an animated application that needs to respond to mouse,
+ * key, and timer events:
+ *
+ *<pre>
+ *    GTimer timer(ANIMATION_DELAY_IN_MILLISECONDS);
+ *    timer.start();
+ *    while (true) {
+ *       GEvent e = waitForEvent(TIMER_EVENT + MOUSE_EVENT + KEY_EVENT);
+ *       switch (e.getEventClass()) {
+ *        case TIMER_EVENT:
+ *          takeAnimationStep();
+ *          break;
+ *        case MOUSE_EVENT:
+ *          handleMouseEvent(GMouseEvent(e));
+ *          break;
+ *        case KEY_EVENT:
+ *          handleKeyEvent(GKeyEvent(e));
+ *          break;
+ *       }
+ *    }
+ *</pre>
+ */
+
+GEvent waitForEvent(int mask = ANY_EVENT);
+
+/*
+ * Function: getNextEvent
+ * Usage: GEvent e = getNextEvent(mask);
+ * -------------------------------------
+ * Checks to see if there are any events of the desired type waiting on the
+ * event queue.  If so, this function returns the event in exactly the same
+ * fashion as <code>waitForEvent</code>; if not, <code>getNextEvent</code>
+ * returns an invalid event.  The <code>mask</code> parameter is optional.
+ * If it is missing, <code>getNextEvent</code> accepts any event.
+ */
+
+GEvent getNextEvent(int mask = ANY_EVENT);
+
+/*
+ * Class: GWindowEvent
+ * -------------------
+ * This event subclass represents a window event.
+ * Each <code>GWindowEvent</code> keeps track of the event type
+ * (<code>WINDOW_CLOSED</code>, <code>WINDOW_RESIZED</code>) along
+ * with the identity of the window.
+ */
+
+class GWindowEvent : public GEvent {
+
+public:
+
+/*
+ * Constructor: GWindowEvent
+ * Usage: GWindowEvent windowEvent(type, gw);
+ * ------------------------------------------
+ * Creates a <code>GWindowEvent</code> using the specified parameters.
+ */
+
+   GWindowEvent(EventType type, const GWindow & gw);
+
+/*
+ * Method: getGWindow
+ * Usage: GWindow gw = e.getGWindow();
+ * -----------------------------------
+ * Returns the graphics window in which this event occurred.
+ */
+
+   GWindow getGWindow() const;
+
+/*
+ * Method: toString
+ * Usage: string str = e.toString();
+ * ---------------------------------
+ * Converts the event to a human-readable representation of the event.
+ */
+
+   std::string toString() const;
+
+/* Private section */
+
+   GWindowEvent();
+   GWindowEvent(GEvent e);
+
+};
+
+/*
+ * Class: GActionEvent
+ * -------------------
+ * This event subclass represents an action event.
+ * Action events are generated by the classes in the
+ * <a href="GInteractor-class.html"><code>GInteractor</code></a>
+ * hierarchy.  As an example, the following program displays
+ * a button that, when pushed, generates the message
+ * &ldquo;Please do not press this button again&rdquo;
+ * (with thanks to Douglas Adams&rsquo;s <i>Hitchhiker&rsquo;s
+ * Guide to the Galaxy</i>):
+ *
+ *<pre>
+ *    int main() {
+ *       GWindow gw;
+ *       GButton *button = new GButton("RED");
+ *       gw.addToRegion(button, "SOUTH");
+ *       while (true) {
+ *          GEvent e = waitForEvent(ACTION_EVENT | CLICK_EVENT);
+ *          if (e.getEventType() == MOUSE_CLICKED) break;
+ *          cout << "Please do not press this button again." << endl;
+ *       }
+ *       return 0;
+ *    }
+ *</pre>
+ */
+
+class GActionEvent : public GEvent {
+
+public:
+
+/*
+ * Constructor: GActionEvent
+ * Usage: GActionEvent actionEvent(type, source, actionCommand);
+ * -------------------------------------------------------------
+ * Creates a <code>GActionEvent</code> using the specified parameters.
+ */
+
+   GActionEvent(EventType type, GObject *source, std::string actionCommand);
+
+/*
+ * Method: getSource
+ * Usage: GObject *gobj = e.getSource();
+ * -------------------------------------
+ * Returns a pointer to the <code>GObject</code> that generated this event.
+ */
+
+   GObject *getSource() const;
+
+/*
+ * Method: getActionCommand
+ * Usage: string cmd = e.getActionCommand();
+ * -----------------------------------------
+ * Returns the action command associated with this event.
+ */
+
+   std::string getActionCommand() const;
+
+/*
+ * Method: toString
+ * Usage: string str = e.toString();
+ * ---------------------------------
+ * Converts the event to a human-readable representation of the event.
+ */
+
+   std::string toString() const;
+
+/* Private section */
+
+   GActionEvent();
+   GActionEvent(GEvent e);
+
+};
+
+/*
+ * Class: GMouseEvent
+ * ------------------
+ * This event subclass represents a mouse event.  Each mouse event
+ * records the event type (<code>MOUSE_PRESSED</code>,
+ * <code>MOUSE_RELEASED</code>, <code>MOUSE_CLICKED</code>,
+ * <code>MOUSE_MOVED</code>, <code>MOUSE_DRAGGED</code>) along
+ * with the coordinates of the event.  Clicking the mouse generates
+ * three events in the following order: <code>MOUSE_PRESSED</code>,
+ * <code>MOUSE_RELEASED</code>, <code>MOUSE_CLICKED</code>.
+ *
+ * <p>As an example, the following program uses mouse events to let
+ * the user draw rectangles on the graphics window.  The only
+ * complexity in this code is the use of the library functions
+ * <code>min</code> and <code>abs</code> to ensure that the
+ * dimensions of the rectangle are positive.
+ *
+ *<pre>
+ *    int main() {
+ *       GWindow gw;
+ *       cout << "This program lets the user draw rectangles." << endl;
+ *       GRect *rect;
+ *       double startX;
+ *       double startY;
+ *       while (true) {
+ *          GMouseEvent e = waitForEvent();
+ *          if (e.getEventType() == MOUSE_PRESSED) {
+ *             startX = e.getX();
+ *             startY = e.getY();
+ *             rect = new GRect(startX, startY, 0, 0);
+ *             rect->setFilled(true);
+ *             gw.add(rect);
+ *          } else if (e.getEventType() == MOUSE_DRAGGED) {
+ *             double x = min(e.getX(), startX);
+ *             double y = min(e.getY(), startY);
+ *             double width = abs(e.getX() - startX);
+ *             double height = abs(e.getY() - startY);
+ *             rect->setBounds(x, y, width, height);
+ *          }
+ *       }
+ *    }
+ *</pre>
+ */
+
+class GMouseEvent : public GEvent {
+
+public:
+
+/*
+ * Constructor: GMouseEvent
+ * Usage: GMouseEvent mouseEvent(type, gw, x, y);
+ * ----------------------------------------------
+ * Creates a <code>GMouseEvent</code> using the specified parameters.
+ */
+
+   GMouseEvent(EventType type, const GWindow & gw, double x, double y);
+
+/*
+ * Method: getGWindow
+ * Usage: GWindow gw = e.getGWindow();
+ * -----------------------------------
+ * Returns the graphics window in which this event occurred.
+ */
+
+   GWindow getGWindow() const;
+
+/*
+ * Method: getX
+ * Usage: double x = getX();
+ * -------------------------
+ * Returns the <i>x</i> coordinate at which the event occurred relative
+ * to the window origin at the upper left corner of the window.
+ */
+
+   double getX() const;
+
+/*
+ * Method: getY
+ * Usage: double y = getY();
+ * -------------------------
+ * Returns the <i>y</i> coordinate at which the event occurred relative
+ * to the window origin at the upper left corner of the window.
+ */
+
+   double getY() const;
+
+/*
+ * Method: toString
+ * Usage: string str = e.toString();
+ * ---------------------------------
+ * Converts the event to a human-readable representation of the event.
+ */
+
+   std::string toString() const;
+
+/* Private section */
+
+   GMouseEvent();
+   GMouseEvent(GEvent e);
+
+};
+
+/*
+ * Class: GKeyEvent
+ * ----------------
+ * This event subclass represents a key event.  Each key event records
+ * the event type along with two representations of the key.  The
+ * <code>getKeyChar</code> function is more generally useful and
+ * returns the character after taking into account modifier keys.
+ * The <code>getKeyCode</code> function returns an integer identifying
+ * the key, which can be a function key as well as a standard key.
+ * The codes return by <code>getKeyCode</code> are listed in the
+ * <code>KeyCodes</code> enumeration.
+ */
+
+class GKeyEvent : public GEvent {
+
+public:
+
+/*
+ * Constructor: GKeyEvent
+ * Usage: GKeyEvent keyEvent(type, gw, keyChar, keyCode);
+ * ------------------------------------------------------
+ * Creates a <code>GKeyEvent</code> using the specified parameters.
+ */
+
+   GKeyEvent(EventType type, const GWindow & gw, int keyChar, int keyCode);
+
+/*
+ * Method: getGWindow
+ * Usage: GWindow gw = e.getGWindow();
+ * -----------------------------------
+ * Returns the graphics window in which this event occurred.
+ */
+
+   GWindow getGWindow() const;
+
+/*
+ * Method: getKeyChar
+ * Usage: char ch = e.getKeyChar();
+ * --------------------------------
+ * Returns the character represented by the keystroke, taking the modifier
+ * keys into account.  For example, if the user types the <code>'a'</code>
+ * key with the shift key down, <code>getKeyChar</code> will return
+ * <code>'A'</code>.  If the key code in the event does not correspond
+ * to a character, <code>getKeyChar</code> returns the null character.
+ */
+
+   char getKeyChar() const;
+
+/*
+ * Method: getKeyCode
+ * Usage: int key = getKeyCode();
+ * ------------------------------
+ * Returns the integer code associated with the key in the event.
+ */
+
+   int getKeyCode() const;
+
+/*
+ * Method: toString
+ * Usage: string str = e.toString();
+ * ---------------------------------
+ * Converts the event to a human-readable representation of the event.
+ */
+
+   std::string toString() const;
+
+/* Private section */
+
+   GKeyEvent();
+   GKeyEvent(GEvent e);
+
+};
+
+/*
+ * Class: GTimerEvent
+ * ------------------
+ * This event subclass represents a timer event.  Timer events are
+ * generated by a <a href="GTimer-class.html"><code>GTimer</code></a>
+ * object, which produces a new event at a fixed interval measured in
+ * milliseconds.  As an example, the following program generates a
+ * timer event every two seconds, stopping when the user clicks
+ * somewhere in the window:
+ *
+ *<pre>
+ *    int main() {
+ *       cout << "This program generates timer events." << endl;
+ *       GTimer timer(2000);
+ *       timer.start();
+ *       while (true) {
+ *          GEvent e = waitForEvent(CLICK_EVENT | TIMER_EVENT);
+ *          if (e.getEventType() == MOUSE_CLICKED) break;
+ *          cout << "Timer ticked" << endl;
+ *       }
+ *       return 0;
+ *    }
+ *</pre>
+ */
+
+class GTimerEvent : public GEvent {
+
+public:
+
+/*
+ * Constructor: GTimerEvent
+ * Usage: GTimerEvent timerEvent(type, timer);
+ * -------------------------------------------
+ * Creates a <code>GTimerEvent</code> for the specified timer.
+ */
+
+   GTimerEvent(EventType type, const GTimer & timer);
+
+/*
+ * Method: getGTimer
+ * Usage: GTimer timer = e.getGTimer();
+ * ------------------------------------
+ * Returns the timer that generated this event.
+ */
+
+   GTimer getGTimer() const;
+
+/*
+ * Method: toString
+ * Usage: string str = e.toString();
+ * ---------------------------------
+ * Converts the event to a human-readable representation of the event.
+ */
+
+   std::string toString() const;
+
+/* Private section */
+
+   GTimerEvent();
+   GTimerEvent(GEvent e);
+
+};
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/ginteractors.cpp b/labb8/lib/StanfordCPPLib/ginteractors.cpp
new file mode 100755
index 0000000..8075372
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/ginteractors.cpp
@@ -0,0 +1,204 @@
+/*
+ * File: gobjects.cpp
+ * ------------------
+ * This file implements the ginteractors.h interface.
+ */
+
+#include <iostream>
+#include <sstream>
+#include "gevents.h"
+#include "ginteractors.h"
+#include "gobjects.h"
+#include "gtypes.h"
+#include "gwindow.h"
+#include "platform.h"
+
+static Platform *pp = getPlatform();
+
+/*
+ * Implementation notes: GInteractor class
+ * ---------------------------------------
+ */
+
+GInteractor::GInteractor() {
+   actionCommand = "";
+}
+
+void GInteractor::setActionCommand(string cmd) {
+   actionCommand = cmd;
+   pp->setActionCommand(this, cmd);
+}
+
+string GInteractor::getActionCommand() {
+   return actionCommand;
+}
+
+void GInteractor::setSize(const GDimension & size) {
+   setSize(size.getWidth(), size.getHeight());
+}
+
+void GInteractor::setSize(double width, double height) {
+   pp->setSize(this, width, height);
+}
+
+void GInteractor::setBounds(const GRectangle & rect) {
+   setLocation(rect.getX(), rect.getY());
+   setSize(rect.getWidth(), rect.getHeight());
+}
+
+void GInteractor::setBounds(double x, double y, double width, double height) {
+   setLocation(x, y);
+   setSize(width, height);
+}
+
+GRectangle GInteractor::getBounds() const {
+   GDimension size = pp->getSize((GObject *) this);
+   return GRectangle(x, y, size.getWidth(), size.getHeight());
+}
+
+/*
+ * Implementation notes: GButton class
+ * -----------------------------------
+ */
+
+GButton::GButton(string label) {
+   this->label = label;
+   pp->createGButton(this, label);
+}
+
+string GButton::getType() const {
+   return "GButton";
+}
+
+string GButton::toString() const {
+   ostringstream oss;
+   oss << "GButton(\"" << label << "\")";
+   return oss.str();
+}
+
+/*
+ * Implementation notes: GCheckBox class
+ * -------------------------------------
+ */
+
+GCheckBox::GCheckBox(string label) {
+   this->label = label;
+   pp->createGCheckBox(this, label);
+}
+
+bool GCheckBox::isSelected() {
+   return pp->isSelected(this);
+}
+
+void GCheckBox::setSelected(bool state) {
+   pp->setSelected(this, state);
+}
+
+string GCheckBox::getType() const {
+   return "GCheckBox";
+}
+
+string GCheckBox::toString() const {
+   ostringstream oss;
+   oss << "GCheckBox(\"" << label << "\")";
+   return oss.str();
+}
+
+/*
+ * Implementation notes: GSlider class
+ * -----------------------------------
+ */
+
+GSlider::GSlider() {
+   create(0, 100, 50);
+}
+
+GSlider::GSlider(int min, int max, int value) {
+   create(min, max, value);
+}
+
+int GSlider::getValue() {
+   return pp->getValue(this);
+}
+
+void GSlider::setValue(int value) {
+   pp->setValue(this, value);
+}
+
+string GSlider::getType() const {
+   return "GSlider";
+}
+
+string GSlider::toString() const {
+   ostringstream oss;
+   oss << "GSlider()";
+   return oss.str();
+}
+
+void GSlider::create(int min, int max, int value) {
+   this->min = min;
+   this->max = max;
+   pp->createGSlider(this, min, max, value);
+}
+
+/*
+ * Implementation notes: GTextField class
+ * --------------------------------------
+ */
+
+GTextField::GTextField() {
+   pp->createGTextField(this, 10);
+}
+
+GTextField::GTextField(int nChars) {
+   pp->createGTextField(this, nChars);
+}
+
+string GTextField::getText() {
+   return pp->getText(this);
+}
+
+void GTextField::setText(string str) {
+   pp->setText(this, str);
+}
+
+string GTextField::getType() const {
+   return "GTextField";
+}
+
+string GTextField::toString() const {
+   ostringstream oss;
+   oss << "GTextField()";
+   return oss.str();
+}
+
+/*
+ * Implementation notes: GChooser class
+ * ------------------------------------
+ */
+
+GChooser::GChooser() {
+   pp->createGChooser(this);
+}
+
+void GChooser::addItem(string item) {
+   pp->addItem(this, item);
+}
+
+string GChooser::getSelectedItem() {
+   return pp->getSelectedItem(this);
+}
+
+void GChooser::setSelectedItem(string item) {
+   pp->setSelectedItem(this, item);
+}
+
+string GChooser::getType() const {
+   return "GChooser";
+}
+
+string GChooser::toString() const {
+   ostringstream oss;
+   oss << "GChooser()";
+   return oss.str();
+}
diff --git a/labb8/lib/StanfordCPPLib/ginteractors.h b/labb8/lib/StanfordCPPLib/ginteractors.h
new file mode 100755
index 0000000..f439324
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/ginteractors.h
@@ -0,0 +1,370 @@
+/*
+ * File: ginteractors.h
+ * --------------------
+ * This file exports a hierarchy of graphical interactors similar to those
+ * provided in the Java Swing libraries.
+ * <include src="pictures/ClassHierarchies/GInteractorHierarchy-h.html">
+ */
+
+#ifndef _ginteractors_h
+#define _ginteractors_h
+
+#include "gobjects.h"
+#include "gtypes.h"
+#include "gwindow.h"
+#include "vector.h"
+
+/*
+ * Class: GInteractor
+ * ------------------
+ * This abstract class is the superclass for all graphical interactors.
+ * In most applications, interactors will be added to a control strip
+ * along one of the sides of the <code>GWindow</code>, but they can
+ * also be placed in specific positions just like any other
+ * <code>GObject</code>.
+ * <include src="pictures/ClassHierarchies/GInteractorHierarchy.html">
+ */
+
+class GInteractor : public GObject {
+
+public:
+
+/*
+ * Method: setActionCommand
+ * Usage: interactor.setActionCommand(cmd);
+ * ----------------------------------------
+ * Sets the action command to the indicated string.  If the string is not
+ * empty, activating the interactor generates a <code>GActionEvent</code>.
+ */
+
+   void setActionCommand(std::string cmd);
+
+/*
+ * Method: getActionCommand
+ * Usage: string cmd = interactor.getActionCommand();
+ * --------------------------------------------------
+ * Returns the action command associated with the interactor.
+ */
+
+   std::string getActionCommand();
+
+/*
+ * Method: setSize
+ * Usage: interactor.setSize(size);
+ *        interactor.setSize(width, height);
+ * -----------------------------------------
+ * Changes the size of the interactor to the specified width and height.
+ */
+
+   void setSize(const GDimension & size);
+   void setSize(double width, double height);
+
+/*
+ * Method: setBounds
+ * Usage: interactor.setBounds(rect);
+ *        interactor.setBounds(x, y, width, height);
+ * -------------------------------------------------
+ * Changes the bounds of the interactor to the specified values.
+ */
+
+   void setBounds(const GRectangle & size);
+   void setBounds(double x, double y, double width, double height);
+
+/* Prototypes for the virtual methods */
+
+   virtual GRectangle getBounds() const;
+
+protected:
+
+   GInteractor();
+
+   std::string actionCommand;
+
+};
+
+/*
+ * Class: GButton
+ * --------------
+ * This interactor subclass represents an onscreen button.  The following
+ * program displays a button that, when pressed, generates the message
+ * &ldquo;Please do not press this button again&rdquo;
+ * (with thanks to Douglas Adams&rsquo;s <i>Hitchhiker&rsquo;s
+ * Guide to the Galaxy</i>):
+ *
+ *<pre>
+ *    int main() {
+ *       GWindow gw;
+ *       GButton *button = new GButton("RED");
+ *       gw.addToRegion(button, "SOUTH");
+ *       while (true) {
+ *          GEvent e = waitForEvent(ACTION_EVENT | CLICK_EVENT);
+ *          if (e.getEventType() == MOUSE_CLICKED) break;
+ *          cout << "Please do not press this button again." << endl;
+ *       }
+ *       return 0;
+ *    }
+ *</pre>
+ */
+
+class GButton : public GInteractor {
+
+public:
+
+/*
+ * Constructor: GButton
+ * Usage: GButton *button = new GButton(label);
+ * --------------------------------------------
+ * Creates a <code>GButton</code> with the specified label.  This
+ * constructor also sets the action command for the button to the
+ * label string.
+ */
+
+   GButton(std::string label);
+
+/* Prototypes for the virtual methods */
+
+   virtual std::string getType() const;
+   virtual std::string toString() const;
+
+private:
+   std::string label;
+
+};
+
+/*
+ * Class: GCheckBox
+ * ----------------
+ * This interactor subclass represents an onscreen check box.  Clicking
+ * once on the check box selects it; clicking again removes the selection.
+ * If a <code>GCheckBox</code> has an action command, clicking on the box
+ * generates a <code>GActionEvent</code>.
+ * <include src="pictures/GInteractorDiagrams/GCheckBox.html">
+ */
+
+class GCheckBox : public GInteractor {
+
+public:
+
+/*
+ * Constructor: GCheckBox
+ * Usage: GCheckBox *chkbox = new GCheckBox(label);
+ * ------------------------------------------------
+ * Creates a <code>GCheckBox</code> with the specified label.  In contrast
+ * to the <code>GButton</code> constructor, this constructor does not set
+ * an action command.
+ */
+
+   GCheckBox(std::string label);
+
+/*
+ * Method: setSelected
+ * Usage: chkbox->setSelected(state);
+ * ----------------------------------
+ * Sets the state of the check box.
+ */
+
+   void setSelected(bool state);
+
+/*
+ * Method: isSelected
+ * Usage: if (chkbox->isSelected()) ...
+ * ------------------------------------
+ * Returns <code>true</code> if the check box is selected.
+ */
+
+   bool isSelected();
+
+/* Prototypes for the virtual methods */
+
+   virtual std::string getType() const;
+   virtual std::string toString() const;
+
+private:
+   std::string label;
+
+};
+
+/*
+ * Class: GSlider
+ * --------------
+ * This interactor subclass represents an onscreen slider.  Dragging
+ * the slider control generates an <code>ActionEvent</code> if the
+ * slider has a nonempty action command.
+ * <include src="pictures/GInteractorDiagrams/GSlider.html">
+ */
+
+class GSlider : public GInteractor {
+
+public:
+
+/*
+ * Constructor: GSlider
+ * Usage: GSlider *slider = new GSlider();
+ *        GSlider *slider = new GSlider(min, max, value);
+ * ------------------------------------------------------
+ * Creates a horizontal <code>GSlider</code>.  The second form allows
+ * the client to specify the minimum value, maximum value, and current
+ * value of the slider.  The first form is equivalent to calling
+ * <code>GSlider(0, 100, 50)</code>.  Assigning an action command
+ * to the slider causes the slider to generate an action event whenever
+ * the slider value changes.
+ */
+
+   GSlider();
+   GSlider(int min, int max, int value);
+
+/*
+ * Method: setValue
+ * Usage: slider->setValue(value);
+ * -------------------------------
+ * Sets the current value of the slider.
+ */
+
+   void setValue(int value);
+
+/*
+ * Method: getValue
+ * Usage: int value = slider->getValue();
+ * --------------------------------------
+ * Returns the current value of the slider.
+ */
+
+   int getValue();
+
+/* Prototypes for the virtual methods */
+
+   virtual std::string getType() const;
+   virtual std::string toString() const;
+
+private:
+   void create(int min, int max, int value);
+   int min;
+   int max;
+
+};
+
+/*
+ * Class: GTextField
+ * -----------------
+ * This interactor subclass represents a text field for entering short
+ * text strings.  Hitting enter in a text field generates a
+ * <code>GActionEvent</code> if the text field has a nonempty action command.
+
+ */
+
+class GTextField : public GInteractor {
+
+public:
+
+/*
+ * Constructor: GTextField
+ * Usage: GTextField *field = new GTextField();
+ *        GTextField *field = new GTextField(nChars);
+ * --------------------------------------------------
+ * Creates a text field capable of holding <code>nChars</code> characters,
+ * which defaults to 10.  Assigning an action command to the text field
+ * causes it to generate an action event whenever the user types the
+ * ENTER key.
+ */
+
+   GTextField();
+   GTextField(int nChars);
+
+/*
+ * Method: setText
+ * Usage: field->setText(str);
+ * ---------------------------
+ * Sets the text of the field to the specified string.
+ */
+
+   void setText(std::string str);
+
+/*
+ * Method: getText
+ * Usage: string str = field->getText();
+ * -------------------------------------
+ * Returns the contents of the text field.
+ */
+
+   std::string getText();
+
+/* Prototypes for the virtual methods */
+
+   virtual std::string getType() const;
+   virtual std::string toString() const;
+
+};
+
+/*
+ * Class: GChooser
+ * ---------------
+ * This interactor subclass represents a selectable list.  The
+ * <code>GChooser</code> constructor creates an empty chooser.
+ * Once the chooser has been created, clients can use <code>addItem</code>
+ * to add the options.  For example, the following code creates a
+ * <code>GChooser</code> containing the four strings
+ * <code>"Small"</code>, <code>"Medium"</code>, <code>"Large"</code>,
+ * and <code>"X-Large"</code>:
+ *
+ *<pre>
+ *    GChooser *sizeChooser = new GChooser();
+ *    sizeChooser->addItem("Small");
+ *    sizeChooser->addItem("Medium");
+ *    sizeChooser->addItem("Large");
+ *    sizeChooser->addItem("X-Large");
+ *</pre>
+ *<include src="pictures/GInteractorDiagrams/GChooser.html">
+ */
+
+class GChooser : public GInteractor {
+
+public:
+
+/*
+ * Constructor: GChooser
+ * Usage: GChooser *chooser = new GChooser();
+ * ------------------------------------------
+ * Creates a chooser that initially contains no items, which are added
+ * using the <code>addItem</code> method.  Assigning an action command
+ * to the chooser causes it to generate an action event whenever the
+ * user selects an item.
+ */
+
+   GChooser();
+
+/*
+ * Method: addItem
+ * Usage: chooser->addItem(item);
+ * ------------------------------
+ * Adds a new item consisting of the specified string.
+ */
+
+   void addItem(std::string item);
+
+/*
+ * Method: setSelectedItem
+ * Usage: chooser->setSelectedItem(item);
+ * --------------------------------------
+ * Sets the chooser so that it shows the specified item.  If the item
+ * does not exist in the chooser, no change occurs.
+ */
+
+   void setSelectedItem(std::string item);
+
+/*
+ * Method: getSelectedItem
+ * Usage: string item = chooser->getSelectedItem();
+ * ------------------------------------------------
+ * Returns the current item selected in the chooser.
+ */
+
+   std::string getSelectedItem();
+
+/* Prototypes for the virtual methods */
+
+   virtual std::string getType() const;
+   virtual std::string toString() const;
+
+};
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/gmath.cpp b/labb8/lib/StanfordCPPLib/gmath.cpp
new file mode 100755
index 0000000..a5ff934
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/gmath.cpp
@@ -0,0 +1,50 @@
+/*
+ * File: gmath.cpp
+ * ---------------
+ * This file implements the gmath.h interface.  In all cases, the
+ * implementation for each function requires only one line of code,
+ * which makes detailed documentation unnecessary.
+ */
+
+#include <cmath>
+#include "gmath.h"
+#include "gtypes.h"
+
+extern const double PI = 3.14159265358979323846;
+extern const double E  = 2.71828182845904523536;
+
+double sinDegrees(double angle) {
+   return sin(toRadians(angle));
+}
+
+double cosDegrees(double angle) {
+   return cos(toRadians(angle));
+}
+
+double tanDegrees(double angle) {
+   return tan(toRadians(angle));
+}
+
+double toDegrees(double radians) {
+   return radians * 180 / PI;
+}
+
+double toRadians(double degrees) {
+   return degrees * PI / 180;
+}
+
+double vectorDistance(const GPoint & pt) {
+   return vectorDistance(pt.getX(), pt.getY());
+}
+
+double vectorDistance(double x, double y) {
+   return sqrt(x * x + y * y);
+}
+
+double vectorAngle(const GPoint & pt) {
+   return vectorAngle(pt.getX(), pt.getY());
+}
+
+double vectorAngle(double x, double y) {
+  return (x == 0 && y == 0) ? 0 : toDegrees(atan2(-y, x));
+}
diff --git a/labb8/lib/StanfordCPPLib/gmath.h b/labb8/lib/StanfordCPPLib/gmath.h
new file mode 100755
index 0000000..7dc8aab
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/gmath.h
@@ -0,0 +1,104 @@
+/*
+ * File: gmath.h
+ * -------------
+ * This file exports several functions for working with graphical
+ * geometry along with the mathematical constants <code>PI</code>
+ * and <code>E</code>.
+ */
+
+#ifndef _gmath_h
+#define _gmath_h
+
+#include "gtypes.h"
+
+/*
+ * Constant: PI
+ * ------------
+ * The mathematical constant pi, which is the ratio of the circumference
+ * of a circle to its diameter.
+ */
+
+extern const double PI;
+
+/*
+ * Constant: E
+ * -----------
+ * The mathematical constant e, which is the base of natural logarithms.
+ */
+
+extern const double E;
+
+/*
+ * Function: sinDegrees
+ * Usage: double sine = sinDegrees(angle);
+ * ---------------------------------------
+ * Returns the trigonometric sine of <code>angle</code>, which is
+ * expressed in degrees.
+ */
+
+double sinDegrees(double angle);
+
+/*
+ * Function: cosDegrees
+ * Usage: double cosine = cosDegrees(angle);
+ * -----------------------------------------
+ * Returns the trigonometric cosine of <code>angle</code>, which is
+ * expressed in degrees.
+ */
+
+double cosDegrees(double angle);
+
+/*
+ * Function: tanDegrees
+ * Usage: double tangent = tanDegrees(angle);
+ * ------------------------------------------
+ * Returns the trigonometric tangent of <code>angle</code>, which is
+ * expressed in degrees.
+ */
+
+double tanDegrees(double angle);
+
+/*
+ * Function: toDegrees
+ * Usage: double degrees = toDegrees(radians);
+ * -------------------------------------------
+ * Converts an angle from radians to degrees.
+ */
+
+double toDegrees(double radians);
+
+/*
+ * Function: toRadians
+ * Usage: double radians = toRadians(degrees);
+ * -------------------------------------------
+ * Converts an angle from degrees to radians.
+ */
+
+double toRadians(double degrees);
+
+/*
+ * Function: vectorDistance
+ * Usage: double r = vectorDistance(pt);
+ *        double r = vectorDistance(x, y);
+ * ---------------------------------------
+ * Computes the distance between the origin and the specified point.
+ */
+
+double vectorDistance(const GPoint & pt);
+double vectorDistance(double x, double y);
+
+/*
+ * Function: vectorAngle
+ * Usage: double angle = vectorAngle(pt);
+ *        double angle = vectorAngle(x, y);
+ * ----------------------------------------
+ * Returns the angle in degrees from the origin to the specified point.
+ * This function takes account of the fact that the graphics coordinate
+ * system is flipped in the <i>y</i> direction from the traditional
+ * Cartesian plane.
+ */
+
+double vectorAngle(const GPoint & pt);
+double vectorAngle(double x, double y);
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/gobjects.cpp b/labb8/lib/StanfordCPPLib/gobjects.cpp
new file mode 100755
index 0000000..ea22894
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/gobjects.cpp
@@ -0,0 +1,1033 @@
+/*
+ * File: gobjects.cpp
+ * ------------------
+ * This file implements the gobjects.h interface.
+ */
+
+#include <cmath>
+#include <iostream>
+#include <sstream>
+#include "gevents.h"
+#include "gmath.h"
+#include "gobjects.h"
+#include "gtypes.h"
+#include "gwindow.h"
+#include "platform.h"
+#include "vector.h"
+
+static Platform *pp = getPlatform();
+
+const double LINE_TOLERANCE = 1.5;
+const double ARC_TOLERANCE = 2.5;
+const double DEFAULT_CORNER = 10;
+const string DEFAULT_GLABEL_FONT = "Dialog-13";
+
+static double dsq(double x0, double y0, double x1, double y1);
+
+double GObject::getX() const {
+   return x;
+}
+
+double GObject::getY() const {
+   return y;
+}
+
+GPoint GObject::getLocation() const {
+   return GPoint(x, y);
+}
+
+void GObject::setLocation(const GPoint & pt) {
+   setLocation(pt.getX(), pt.getY());
+}
+
+void GObject::setLocation(double x, double y) {
+   this->x = x;
+   this->y = y;
+   pp->setLocation(this, x, y);
+}
+
+void GObject::move(double dx, double dy) {
+   setLocation(x + dx, y + dy);
+}
+
+double GObject::getWidth() const {
+   return getBounds().getWidth();
+}
+
+double GObject::getHeight() const {
+   return getBounds().getHeight();
+}
+
+GDimension GObject::getSize() const {
+   GRectangle bounds = getBounds();
+   return GDimension(bounds.getWidth(), bounds.getHeight());
+}
+
+void GObject::setLineWidth(double lineWidth) {
+   this->lineWidth = lineWidth;
+   pp->setLineWidth(this, lineWidth);
+}
+
+double GObject::getLineWidth() const {
+   return lineWidth;
+}
+
+void GObject::setColor(string color) {
+   setColor(convertColorToRGB(color));
+}
+
+void GObject::setColor(int rgb) {
+   this->color = convertRGBToColor(rgb);
+   pp->setColor(this, this->color);
+}
+
+string GObject::getColor() const {
+   return color;
+}
+
+void GObject::scale(double sf) {
+   scale(sf, sf);
+}
+
+void GObject::scale(double sx, double sy) {
+   // Apply local transform
+   transformed = true;
+   pp->scale(this, sx, sy);
+}
+
+void GObject::rotate(double theta) {
+   // Apply local transform
+   transformed = true;
+   pp->rotate(this, theta);
+}
+
+void GObject::setVisible(bool flag) {
+   visible = flag;
+   pp->setVisible(this, flag);
+}
+
+bool GObject::isVisible() const {
+   return visible;
+}
+
+void GObject::sendForward() {
+   GCompound *parent = getParent();
+   if (parent != NULL) parent->sendForward(this);
+}
+
+void GObject::sendToFront() {
+   GCompound *parent = getParent();
+   if (parent != NULL) parent->sendToFront(this);
+}
+
+void GObject::sendBackward() {
+   GCompound *parent = getParent();
+   if (parent != NULL) parent->sendBackward(this);
+}
+
+void GObject::sendToBack() {
+   GCompound *parent = getParent();
+   if (parent != NULL) parent->sendToBack(this);
+}
+
+bool GObject::contains(GPoint pt) const {
+   return contains(pt.getX(), pt.getY());
+}
+
+bool GObject::contains(double x, double y) const {
+   if (transformed) return pp->contains(this, x, y);
+   return getBounds().contains(x, y);
+}
+
+GCompound *GObject::getParent() const {
+   return parent;
+}
+
+GObject::GObject() {
+   x = 0;
+   y = 0;
+   color = "";
+   lineWidth = 1.0;
+   transformed = false;
+   visible = true;
+}
+
+GObject::~GObject() {
+   pp->deleteGObject(this);
+}
+
+/*
+ * Implementation notes: GRect class
+ * ---------------------------------
+ * The GRect class is the most straightforward of the shape classes.
+ */
+
+GRect::GRect(double width, double height) {
+   createGRect(width, height);
+}
+
+GRect::GRect(double x, double y, double width, double height) {
+   createGRect(width, height);
+   setLocation(x, y);
+}
+
+GRect::~GRect() {
+   /* Empty */
+}
+
+void GRect::setSize(const GDimension & size) {
+   setSize(size.getWidth(), size.getHeight());
+}
+
+void GRect::setSize(double width, double height) {
+   if (transformed) error("setSize: Object has been transformed");
+   this->width = width;
+   this->height = height;
+   pp->setSize(this, width, height);
+}
+
+void GRect::setBounds(const GRectangle & bounds) {
+   setLocation(bounds.getX(), bounds.getY());
+   setSize(bounds.getWidth(), bounds.getHeight());
+}
+
+void GRect::setBounds(double x, double y, double width, double height) {
+   setLocation(x, y);
+   setSize(width, height);
+}
+
+GRectangle GRect::getBounds() const {
+   if (transformed) return pp->getBounds(this);
+   return GRectangle(x, y, width, height);
+}
+
+void GRect::setFilled(bool flag) {
+   fillFlag = true;
+   pp->setFilled(this, flag);
+}
+
+bool GRect::isFilled() const {
+   return fillFlag;
+}
+
+void GRect::setFillColor(string color) {
+   fillColor = color;
+   if (fillColor != "") {
+      fillColor = convertRGBToColor(convertColorToRGB(color));
+   }
+   pp->setFillColor(this, fillColor);
+}
+
+void GRect::setFillColor(int rgb) {
+   fillColor = convertRGBToColor(rgb);
+   pp->setFillColor(this, fillColor);
+}
+
+string GRect::getFillColor() const {
+   return fillColor;
+}
+
+string GRect::getType() const {
+   return "GRect";
+}
+
+string GRect::toString() const {
+   ostringstream oss;
+   oss << "GRect(" << x << ", " << y << ", "
+                   << width << ", " << height << ")";
+   return oss.str();
+}
+
+GRect::GRect() {
+   /* Called only by the GRoundRect and G3DRect subclasses */
+}
+
+void GRect::createGRect(double width, double height) {
+   this->x = 0;
+   this->y = 0;
+   this->width = width;
+   this->height = height;
+   fillFlag = false;
+   fillColor = "";
+   pp->createGRect(this, width, height);
+}
+
+/*
+ * Implementation notes: GRoundRect class
+ * --------------------------------------
+ * Most of the GRoundRect class is inherited from the GRect class.
+ */
+
+GRoundRect::GRoundRect(double width, double height) {
+   createGRoundRect(width, height, DEFAULT_CORNER);
+}
+
+GRoundRect::GRoundRect(double width, double height, double corner) {
+   createGRoundRect(width, height, corner);
+}
+
+GRoundRect::GRoundRect(double x, double y, double width, double height) {
+   createGRoundRect(width, height, DEFAULT_CORNER);
+   setLocation(x, y);
+}
+
+GRoundRect::GRoundRect(double x, double y, double width, double height,
+                       double corner) {
+   createGRoundRect(width, height, corner);
+   setLocation(x, y);
+}
+
+GRoundRect::~GRoundRect() {
+   /* Empty */
+}
+
+string GRoundRect::getType() const {
+   return "GRoundRect";
+}
+
+string GRoundRect::toString() const {
+   ostringstream oss;
+   oss << "GRoundRect(" << x << ", " << y << ", "
+                        << width << ", " << height << ", " << corner << ")";
+   return oss.str();
+}
+
+void GRoundRect::createGRoundRect(double width, double height, double corner) {
+   this->x = 0;
+   this->y = 0;
+   this->width = width;
+   this->height = height;
+   this->corner = corner;
+   fillFlag = false;
+   fillColor = "";
+   pp->createGRoundRect(this, width, height, corner);
+}
+
+/*
+ * Implementation notes: G3DRect class
+ * -----------------------------------
+ * Most of the G3DRect class is inherited from the GRect class.
+ */
+
+G3DRect::G3DRect(double width, double height) {
+   createG3DRect(width, height, false);
+}
+
+G3DRect::G3DRect(double width, double height, bool raised) {
+   createG3DRect(width, height, raised);
+}
+
+G3DRect::G3DRect(double x, double y, double width, double height) {
+   createG3DRect(width, height, false);
+   setLocation(x, y);
+}
+
+G3DRect::G3DRect(double x, double y, double width, double height,
+                           bool raised) {
+   createG3DRect(width, height, raised);
+   setLocation(x, y);
+}
+
+G3DRect::~G3DRect() {
+   /* Empty */
+}
+
+void G3DRect::setRaised(bool raised) {
+   this->raised = raised;
+   pp->setRaised(this, raised);
+}
+
+bool G3DRect::isRaised() const {
+   return raised;
+}
+
+string G3DRect::getType() const {
+   return "G3DRect";
+}
+
+string G3DRect::toString() const {
+   ostringstream oss;
+   oss << boolalpha << "G3DRect(" << x << ", " << y << ", "
+                    << width << ", " << height << ", " << raised << ")";
+   return oss.str();
+}
+
+void G3DRect::createG3DRect(double width, double height, bool raised) {
+   this->x = 0;
+   this->y = 0;
+   this->width = width;
+   this->height = height;
+   this->raised = raised;
+   fillFlag = false;
+   fillColor = "";
+   pp->createG3DRect(this, width, height, raised);
+}
+
+GOval::GOval(double width, double height) {
+   createGOval(width, height);
+}
+
+GOval::GOval(double x, double y, double width, double height) {
+   createGOval(width, height);
+   setLocation(x, y);
+}
+
+GOval::~GOval() {
+   /* Empty */
+}
+
+void GOval::setSize(const GDimension & size) {
+   setSize(size.getWidth(), size.getHeight());
+}
+
+void GOval::setSize(double width, double height) {
+   if (transformed) error("setSize: Object has been transformed");
+   this->width = width;
+   this->height = height;
+   pp->setSize(this, width, height);
+}
+
+void GOval::setBounds(const GRectangle & bounds) {
+   setLocation(bounds.getX(), bounds.getY());
+   setSize(bounds.getWidth(), bounds.getHeight());
+}
+
+void GOval::setBounds(double x, double y, double width, double height) {
+   setLocation(x, y);
+   setSize(width, height);
+}
+
+GRectangle GOval::getBounds() const {
+   if (transformed) return pp->getBounds(this);
+   return GRectangle(x, y, width, height);
+}
+
+bool GOval::contains(double x, double y) const {
+   if (transformed) return pp->contains(this, x, y);
+   double rx = width / 2;
+   double ry = height / 2;
+   if (rx == 0 || ry == 0) return false;
+   double dx = x - (this->x + rx);
+   double dy = y - (this->y + ry);
+   return (dx * dx) / (rx * rx) + (dy * dy) / (ry * ry) <= 1.0;
+}
+
+void GOval::setFilled(bool flag) {
+   fillFlag = true;
+   pp->setFilled(this, flag);
+}
+
+bool GOval::isFilled() const {
+   return fillFlag;
+}
+
+void GOval::setFillColor(string color) {
+   fillColor = color;
+   if (fillColor != "") {
+      fillColor = convertRGBToColor(convertColorToRGB(color));
+   }
+   pp->setFillColor(this, fillColor);
+}
+
+void GOval::setFillColor(int color) {
+   fillColor = convertRGBToColor(color);
+   pp->setFillColor(this, fillColor);
+}
+
+string GOval::getFillColor() const {
+   return fillColor;
+}
+
+string GOval::getType() const {
+   return "GOval";
+}
+
+string GOval::toString() const {
+   ostringstream oss;
+   oss << "GOval(" << x << ", " << y << ", "
+                   << width << ", " << height << ")";
+   return oss.str();
+}
+
+void GOval::createGOval(double width, double height) {
+   this->x = 0;
+   this->y = 0;
+   this->width = width;
+   this->height = height;
+   fillFlag = false;
+   fillColor = "";
+   pp->createGOval(this, width, height);
+}
+
+/* GArc class */
+
+GArc::GArc(double width, double height, double start, double sweep) {
+   createGArc(width, height, start, sweep);
+}
+
+GArc::GArc(double x, double y, double width, double height,
+                               double start, double sweep) {
+   createGArc(width, height, start, sweep);
+   setLocation(x, y);
+}
+
+void GArc::setStartAngle(double start) {
+   this->start = start;
+   pp->setStartAngle(this, start);
+}
+
+double GArc::getStartAngle() const {
+   return start;
+}
+
+void GArc::setSweepAngle(double sweep) {
+   this->sweep = sweep;
+   pp->setSweepAngle(this, sweep);
+}
+
+double GArc::getSweepAngle() const {
+   return sweep;
+}
+
+GPoint GArc::getStartPoint() const {
+   return getArcPoint(start);
+}
+
+GPoint GArc::getEndPoint() const {
+   return getArcPoint(start + sweep);
+}
+
+void GArc::setFrameRectangle(const GRectangle & rect) {
+   setFrameRectangle(rect.getX(), rect.getY(), rect.getWidth(),
+                                                   rect.getHeight());
+}
+
+void GArc::setFrameRectangle(double x, double y, double width, double height) {
+   this->x = x;
+   this->y = y;
+   frameWidth = width;
+   frameHeight = height;
+   pp->setFrameRectangle(this, x, y, width, height);
+}
+
+GRectangle GArc::getFrameRectangle() const {
+   return GRectangle(0, 0, 0, 0);
+}
+
+void GArc::setFilled(bool flag) {
+   fillFlag = true;
+   pp->setFilled(this, flag);
+}
+
+bool GArc::isFilled() const {
+   return fillFlag;
+}
+
+void GArc::setFillColor(string color) {
+   fillColor = color;
+   if (fillColor != "") {
+      fillColor = convertRGBToColor(convertColorToRGB(color));
+   }
+   pp->setFillColor(this, fillColor);
+}
+
+void GArc::setFillColor(int color) {
+   fillColor = convertRGBToColor(color);
+   pp->setFillColor(this, fillColor);
+}
+
+string GArc::getFillColor() const {
+   return fillColor;
+}
+
+GRectangle GArc::getBounds() const {
+   if (transformed) return pp->getBounds(this);
+   double rx = frameWidth / 2;
+   double ry = frameHeight / 2;
+   double cx = x + rx;
+   double cy = y + ry;
+   double startRadians = start * PI / 180;
+   double sweepRadians = sweep * PI / 180;
+   double p1x = cx + cos(startRadians) * rx;
+   double p1y = cy - sin(startRadians) * ry;
+   double p2x = cx + cos(startRadians + sweepRadians) * rx;
+   double p2y = cy - sin(startRadians + sweepRadians) * ry;
+   double xMin = min(p1x, p2x);
+   double xMax = max(p1x, p2x);
+   double yMin = min(p1y, p2y);
+   double yMax = max(p1y, p2y);
+   if (containsAngle(0)) xMax = cx + rx;
+   if (containsAngle(90)) yMin = cy - ry;
+   if (containsAngle(180)) xMin = cx - rx;
+   if (containsAngle(270)) yMax = cy + ry;
+   if (isFilled()) {
+      xMin = min(xMin, cx);
+      yMin = min(yMin, cy);
+      xMax = max(xMax, cx);
+      yMax = max(yMax, cy);
+   }
+   return GRectangle(xMin, yMin, xMax - xMin, yMax - yMin);
+}
+
+bool GArc::contains(double x, double y) const {
+   if (transformed) return pp->contains(this, x, y);
+   double rx = frameWidth / 2;
+   double ry = frameHeight / 2;
+   if (rx == 0 || ry == 0) return false;
+   double dx = x - (this->x + rx);
+   double dy = y - (this->y + ry);
+   double r = (dx * dx) / (rx * rx) + (dy * dy) / (ry * ry);
+   if (fillFlag) {
+      if (r > 1.0) return false;
+   } else {
+      double t = ARC_TOLERANCE / ((rx + ry) / 2);
+      if (abs(1.0 - r) > t) return false;
+   }
+   return containsAngle(atan2(-dy, dx) * 180 / PI);
+}
+
+string GArc::getType() const {
+   return "GArc";
+}
+
+string GArc::toString() const {
+   ostringstream oss;
+   oss << "GArc(" << x << ", " << y << ", " << frameWidth << ", "
+                  << frameHeight << ", " << start << ", " << sweep << ")";
+   return oss.str();
+}
+
+GPoint GArc::getArcPoint(double theta) const {
+   double rx = frameWidth / 2;
+   double ry = frameHeight / 2;
+   double cx = x + rx;
+   double cy = y + ry;
+   double radians = theta * PI / 180;
+   return GPoint(cx + rx * cos(radians), cy - ry * sin(radians));
+}
+
+bool GArc::containsAngle(double theta) const {
+   double start = min(this->start, this->start + this->sweep);
+   double sweep = abs(this->sweep);
+   if (sweep >= 360) return true;
+   theta = (theta < 0) ? 360 - fmod(-theta, 360) : fmod(theta, 360);
+   start = (start < 0) ? 360 - fmod(-start, 360) : fmod(start, 360);
+   if (start + sweep > 360) {
+      return theta >= start || theta <= start + sweep - 360;
+   } else {
+      return theta >= start && theta <= start + sweep;
+   }
+}
+
+void GArc::createGArc(double width, double height, double start, double sweep) {
+   this->x = 0;
+   this->y = 0;
+   frameWidth = width;
+   frameHeight = height;
+   this->start = start;
+   this->sweep = sweep;
+   fillFlag = false;
+   fillColor = "";
+   pp->createGArc(this, width, height, start, sweep);
+}
+
+GCompound::GCompound() {
+   pp->createGCompound(this);
+}
+
+void GCompound::add(GObject *gobj) {
+   pp->add(this, gobj);
+   contents.add(gobj);
+   gobj->parent = this;
+}
+
+void GCompound::add(GObject *gobj, double x, double y) {
+   gobj->setLocation(x, y);
+   add(gobj);
+}
+
+void GCompound::remove(GObject *gobj) {
+   int index = findGObject(gobj);
+   if (index != -1) removeAt(index);
+}
+
+void GCompound::removeAll() {
+   while (!contents.isEmpty()) {
+      removeAt(0);
+   }
+}
+
+int GCompound::getElementCount() {
+   return contents.size();
+}
+
+GObject *GCompound::getElement(int index) {
+   return contents.get(index);
+}
+
+GRectangle GCompound::getBounds() const {
+   if (transformed) return pp->getBounds(this);
+   double xMin = +1E20;
+   double yMin = +1E20;
+   double xMax = -1E20;
+   double yMax = -1E20;
+   for (int i = 0; i < contents.size(); i++) {
+      GRectangle bounds = contents.get(i)->getBounds();
+      xMin = min(xMin, bounds.getX());
+      yMin = min(yMin, bounds.getY());
+      xMax = max(xMax, bounds.getX());
+      yMin = min(yMax, bounds.getY());
+   }
+   return GRectangle(xMin, yMin, xMax - xMin, yMax - yMin);
+}
+
+bool GCompound::contains(double x, double y) const {
+   if (transformed) return pp->contains(this, x, y);
+   for (int i = 0; i < contents.size(); i++) {
+      if (contents.get(i)->contains(x, y)) return true;
+   }
+   return false;
+}
+
+string GCompound::getType() const {
+   return "GCompound";
+}
+
+string GCompound::toString() const {
+   return "GCompound(...)";
+}
+
+void GCompound::sendForward(GObject *gobj) {
+   int index = findGObject(gobj);
+   if (index == -1) return;
+   if (index != contents.size() - 1) {
+      contents.remove(index);
+      contents.insert(index + 1, gobj);
+      pp->sendForward(gobj);
+   }
+}
+
+void GCompound::sendToFront(GObject *gobj) {
+   int index = findGObject(gobj);
+   if (index == -1) return;
+   if (index != contents.size() - 1) {
+      contents.remove(index);
+      contents.add(gobj);
+      pp->sendToFront(gobj);
+   }
+}
+
+void GCompound::sendBackward(GObject *gobj) {
+   int index = findGObject(gobj);
+   if (index == -1) return;
+   if (index != 0) {
+      contents.remove(index);
+      contents.insert(index - 1, gobj);
+      pp->sendBackward(gobj);
+   }
+}
+
+void GCompound::sendToBack(GObject *gobj) {
+   int index = findGObject(gobj);
+   if (index == -1) return;
+   if (index != 0) {
+      contents.remove(index);
+      contents.insert(0, gobj);
+      pp->sendToBack(gobj);
+   }
+}
+
+int GCompound::findGObject(GObject *gobj) {
+   int n = contents.size();
+   for (int i = 0; i < n; i++) {
+      if (contents.get(i) == gobj) return i;
+   }
+   return -1;
+}
+
+void GCompound::removeAt(int index) {
+   GObject *gobj = contents[index];
+   contents.remove(index);
+   pp->remove(gobj);
+   gobj->parent = NULL;
+}
+
+GImage::GImage(string filename) {
+   createGImage(filename);
+}
+
+GImage::GImage(string filename, double x, double y) {
+   createGImage(filename);
+   setLocation(x, y);
+}
+
+GRectangle GImage::getBounds() const {
+   if (transformed) return pp->getBounds(this);
+   return GRectangle(x, y, width, height);
+}
+
+string GImage::getType() const {
+   return "GImage";
+}
+
+string GImage::toString() const {
+   return "GImage(\"" + filename + "\")";
+}
+
+void GImage::createGImage(string filename) {
+   this->filename = filename;
+   GDimension size = pp->createGImage(this, filename);
+   width = size.getWidth();
+   height = size.getHeight();
+}
+
+/*
+ * Implementation notes: GLabel class
+ * ----------------------------------
+ */
+
+GLabel::GLabel(string str) {
+   createGLabel(str);
+}
+
+GLabel::GLabel(string str, double x, double y) {
+   createGLabel(str);
+   setLocation(x, y);
+}
+
+void GLabel::createGLabel(const string & str) {
+   this->str = str;
+   pp->createGLabel(this, str);
+   setFont(DEFAULT_GLABEL_FONT);
+   GDimension size = pp->getGLabelSize(this);
+   width = size.getWidth();
+   height = size.getHeight();
+   ascent = pp->getFontAscent(this);
+   descent = pp->getFontDescent(this);
+}
+
+void GLabel::setFont(string font) {
+   this->font = font;
+   pp->setFont(this, font);
+   GDimension size = pp->getGLabelSize(this);
+   width = size.getWidth();
+   height = size.getHeight();
+   ascent = pp->getFontAscent(this);
+   descent = pp->getFontDescent(this);
+}
+
+string GLabel::getFont() const {
+   return font;
+}
+
+void GLabel::setLabel(string str) {
+   this->str = str;
+   pp->setLabel(this, str);
+   GDimension size = pp->getGLabelSize(this);
+   width = size.getWidth();
+   height = size.getHeight();
+}
+
+string GLabel::getLabel() const {
+   return str;
+}
+
+double GLabel::getFontAscent() const {
+   return ascent;
+}
+
+double GLabel::getFontDescent() const {
+   return descent;
+}
+
+GRectangle GLabel::getBounds() const {
+   if (transformed) return pp->getBounds(this);
+   return GRectangle(x, y - ascent, width, height);
+}
+
+string GLabel::getType() const {
+   return "GLabel";
+}
+
+string GLabel::toString() const {
+   return "GLabel(\"" + str + "\")";
+}
+
+/*
+ * Implementation notes: GLine class
+ * ---------------------------------
+ */
+
+GLine::GLine(double x0, double y0, double x1, double y1) {
+   pp->createGLine(this, x0, y0, x1, y1);
+   x = x0;
+   y = y0;
+   dx = x1 - x0;
+   dy = y1 - y0;
+}
+
+void GLine::setStartPoint(double x, double y) {
+   dx += this->x - x;
+   dy += this->y - y;
+   this->x = x;
+   this->y = y;
+   pp->setStartPoint(this, x, y);
+}
+
+GPoint GLine::getStartPoint() const {
+   return GPoint(x, y);
+}
+
+void GLine::setEndPoint(double x, double y) {
+   dx = x - this->x;
+   dy = y - this->y;
+   pp->setEndPoint(this, x, y);
+}
+
+GPoint GLine::getEndPoint() const {
+   return GPoint(x + dx, y + dy);
+}
+
+GRectangle GLine::getBounds() const {
+   if (transformed) return pp->getBounds(this);
+   double x0 = (dx < 0) ? x + dx : x;
+   double y0 = (dy < 0) ? y + dy : y;
+   return GRectangle(x0, y0, abs(dx), abs(dy));
+}
+
+bool GLine::contains(double x, double y) const {
+   if (transformed) return pp->contains(this, x, y);
+   double x0 = getX();
+   double y0 = getY();
+   double x1 = x0 + dx;
+   double y1 = y0 + dy;
+   double tSquared = LINE_TOLERANCE * LINE_TOLERANCE;
+   if (dsq(x, y, x0, y0) < tSquared) return true;
+   if (dsq(x, y, x1, y1) < tSquared) return true;
+   if (x < min(x0, x1) - LINE_TOLERANCE) return false;
+   if (x > max(x0, x1) + LINE_TOLERANCE) return false;
+   if (y < min(y0, y1) - LINE_TOLERANCE) return false;
+   if (y > max(y0, y1) + LINE_TOLERANCE) return false;
+   if ((float) (x0 - x1) == 0 && (float) (y0 - y1) == 0) return false;
+   double u = ((x - x0) * (x1 - x0) + (y - y0) * (y1 - y0))
+            / dsq(x0, y0, x1, y1);
+   return dsq(x, y, x0 + u * (x1 - x0), y0 + u * (y1 - y0)) < tSquared;
+}
+
+string GLine::getType() const {
+   return "GLine";
+}
+
+string GLine::toString() const {
+   ostringstream oss;
+   oss << "GLine(" << x << ", " << y << ", "
+                   << (x + dx) << ", " << (y + dy) << ")";
+   return oss.str();
+}
+
+/*
+ * Implementation notes: GPolygon class
+ * ------------------------------------
+ */
+
+GPolygon::GPolygon() {
+   fillFlag = false;
+   fillColor = "";
+   pp->createGPolygon(this);
+}
+
+void GPolygon::addVertex(double x, double y) {
+   cx = x;
+   cy = y;
+   vertices.add(GPoint(cx, cy));
+   pp->addVertex(this, cx, cy);
+}
+
+void GPolygon::addEdge(double dx, double dy) {
+   addVertex(cx + dx, cy + dy);
+}
+
+void GPolygon::addPolarEdge(double r, double theta) {
+   addEdge(r * cos(theta * PI / 180), -r * sin(theta * PI / 180));
+}
+
+Vector<GPoint> GPolygon::getVertices() const {
+   return vertices;
+}
+
+void GPolygon::setFilled(bool flag) {
+   fillFlag = true;
+   pp->setFilled(this, flag);
+}
+
+bool GPolygon::isFilled() const {
+   return fillFlag;
+}
+
+void GPolygon::setFillColor(string color) {
+   fillColor = color;
+   if (fillColor != "") {
+      fillColor = convertRGBToColor(convertColorToRGB(color));
+   }
+   pp->setFillColor(this, fillColor);
+}
+
+void GPolygon::setFillColor(int rgb) {
+   fillColor = convertRGBToColor(rgb);
+   pp->setFillColor(this, fillColor);
+}
+
+string GPolygon::getFillColor() const {
+   return fillColor;
+}
+
+GRectangle GPolygon::getBounds() const {
+   if (transformed) return pp->getBounds(this);
+   double xMin = 0;
+   double yMin = 0;
+   double xMax = 0;
+   double yMax = 0;
+   for (int i = 0; i < vertices.size(); i++) {
+      double x = vertices[i].getX();
+      double y = vertices[i].getY();
+      if (i == 0 || x < xMin) xMin = x;
+      if (i == 0 || y < yMin) yMin = y;
+      if (i == 0 || x > xMax) xMax = x;
+      if (i == 0 || y > yMax) yMax = y;
+   }
+   return GRectangle(xMin, yMin, xMax - xMin, yMax - yMin);
+}
+
+bool GPolygon::contains(double x, double y) const {
+   if (transformed) return pp->contains(this, x, y);
+   int crossings = 0;
+   int n = vertices.size();
+   if (n < 2) return false;
+   if (vertices[0] == vertices[n - 1]) n--;
+   double x0 = vertices[0].getX();
+   double y0 = vertices[0].getY();
+   for (int i = 1; i <= n; i++) {
+      double x1 = vertices[i % n].getX();
+      double y1 = vertices[i % n].getY();
+      if ((y0 > y) != (y1 > y) && x - x0 < (x1 - x0) * (y - y0) / (y1 - y0)) {
+         crossings++;
+      }
+      x0 = x1;
+      y0 = y1;
+   }
+   return (crossings % 2 == 1);
+}
+
+string GPolygon::getType() const {
+   return "GPolygon";
+}
+
+string GPolygon::toString() const {
+   ostringstream oss;
+   oss << "GPolygon(" << vertices.size() << " vertices)";
+   return oss.str();
+}
+
+static double dsq(double x0, double y0, double x1, double y1) {
+   return (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0);
+}
diff --git a/labb8/lib/StanfordCPPLib/gobjects.h b/labb8/lib/StanfordCPPLib/gobjects.h
new file mode 100755
index 0000000..f0637bf
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/gobjects.h
@@ -0,0 +1,1491 @@
+/*
+ * File: gobjects.h
+ * ----------------
+ * This file exports a hierarchy of graphical shapes based on
+ * the model developed for the ACM Java Graphics.
+ * <include src="pictures/ClassHierarchies/GObjectHierarchy-h.html">
+ */
+
+#ifndef _gobjects_h
+#define _gobjects_h
+
+#include "gtypes.h"
+#include "gwindow.h"
+#include "vector.h"
+
+class GCompound;
+
+/*
+ * Class: GObject
+ * --------------
+ * This class is the common superclass of all graphical objects that can
+ * be displayed on a graphical window.  The class <code>GObject</code>
+ * itself is an <b><i>abstract class</i></b>, which means that you are not
+ * allowed to construct a <code>GObject</code> directly but must instead
+ * construct one of the concrete subclasses.
+ * <include src="pictures/ClassHierarchies/GObjectHierarchy.html">
+ *
+ * <p>Most methods used for graphics take a pointer to a <code>GObject</code>
+ * rather than the <code>GObject</code> itself.  Applications that use
+ * <code>GObject</code> pointers therefore use the arrow operator
+ * (<code>-&gt;</code>) to apply methods to the object pointer.
+ * For examples illustrating the use of the <code>GObject</code> class, see
+ * the descriptions of the individual subclasses.
+ */
+
+class GObject {
+
+public:
+
+/*
+ * Destructor: ~GObject
+ * --------------------
+ * Frees the storage for the object.
+ */
+
+   virtual ~GObject();
+
+/*
+ * Method: getX
+ * Usage: double x = gobj->getX();
+ * -------------------------------
+ * Returns the <i>x</i>-coordinate of the object.
+ */
+
+   double getX() const;
+
+/*
+ * Method: getY
+ * Usage: double y = gobj->getY();
+ * -------------------------------
+ * Returns the <i>y</i>-coordinate of the object.
+ */
+
+   double getY() const;
+
+/*
+ * Method: getLocation
+ * Usage: GPoint pt = gobj->getLocation();
+ * ---------------------------------------
+ * Returns the location of this object as a <code>GPoint</code>.
+ */
+
+   GPoint getLocation() const;
+
+/*
+ * Method: setLocation
+ * Usage: gobj->setLocation(pt);
+ *        gobj->setLocation(x, y);
+ * -------------------------------
+ * Sets the location of this object to the specified point.
+ */
+
+   void setLocation(const GPoint & pt);
+   void setLocation(double x, double y);
+
+/*
+ * Method: move
+ * Usage: gobj->move(dx, dy);
+ * --------------------------
+ * Moves the object on the screen using the displacements
+ * <code>dx</code> and <code>dy</code>.
+ */
+
+   void move(double dx, double dy);
+
+/*
+ * Method: getWidth
+ * Usage: double width = gobj->getWidth();
+ * ---------------------------------------
+ * Returns the width of this object, which is defined to be the width of
+ * the bounding box.
+ */
+
+   double getWidth() const;
+
+/*
+ * Method: getHeight
+ * Usage: double height = gobj->getHeight();
+ * -----------------------------------------
+ * Returns the height of this object, which is defined to be the height
+ * of the bounding box.
+ */
+
+   double getHeight() const;
+
+/*
+ * Method: getSize
+ * Usage: GDimension size = gobj->getSize();
+ * -----------------------------------------
+ * Returns the size of the object as a <code>GDimension</code>.
+ */
+
+   GDimension getSize() const;
+
+/*
+ * Method: getBounds
+ * Usage: GRectangle rect = gobj->getBounds();
+ * -------------------------------------------
+ * Returns the bounding box of this object, which is defined to be the
+ * smallest rectangle that covers everything drawn by the figure.  The
+ * coordinates of this rectangle do not necessarily match the location
+ * returned by <code>getLocation</code>.  Given a <code>GLabel</code>
+ * object, for example, <code>getLocation</code> returns the coordinates
+ * of the point on the baseline at which the string begins; the
+ * <code>getBounds</code> method, by contrast, returns a rectangle that
+ * covers the entire window area occupied by the string.
+ */
+
+   virtual GRectangle getBounds() const = 0;
+
+/*
+ * Method: setLineWidth
+ * Usage: gobj->setLineWidth(lineWidth);
+ * -------------------------------------
+ * Sets the width of the line used to draw this object.
+ */
+
+   void setLineWidth(double lineWidth);
+
+/*
+ * Method: getLineWidth
+ * Usage: double lineWidth = gobj->getLineWidth();
+ * -----------------------------------------------
+ * Returns the width of the line used to draw this object.
+ */
+
+   double getLineWidth() const;
+
+/*
+ * Method: setColor
+ * Usage: gobj->setColor(color);
+ * -----------------------------
+ * Sets the color used to display this object.  The <code>color</code>
+ * string is usually one of the predefined color names:
+ *
+ *    <code>BLACK</code>,
+ *    <code>BLUE</code>,
+ *    <code>CYAN</code>,
+ *    <code>DARK_GRAY</code>,
+ *    <code>GRAY</code>,
+ *    <code>GREEN</code>,
+ *    <code>LIGHT_GRAY</code>,
+ *    <code>MAGENTA</code>,
+ *    <code>ORANGE</code>,
+ *    <code>PINK</code>,
+ *    <code>RED</code>,
+ *    <code>WHITE</code>, and
+ *    <code>YELLOW</code>.
+ *
+ * The case of the individual letters in the color name is ignored, as
+ * are spaces and underscores, so that the color <code>DARK_GRAY</code>
+ * can be written as <code>"Dark Gray"</code>.
+ *
+ * <p>The color can also be specified as a string in the form
+ * <code>"#rrggbb"</code> where <code>rr</code>, <code>gg</code>, and
+ * <code>bb</code> are pairs of hexadecimal digits indicating the
+ * red, green, and blue components of the color, respectively.
+ */
+
+   void setColor(std::string color);
+   void setColor(int rgb);
+
+/*
+ * Method: getColor
+ * Usage: string color = gobj->getColor();
+ * ---------------------------------------
+ * Returns the color used to display this object.  This color is
+ * always returned as a string in the form <code>"#rrggbb"</code>,
+ * where <code>rr</code>, <code>gg</code>, and <code>bb</code> are
+ * the red, green, and blue components of the color, expressed as
+ * two-digit hexadecimal values.
+ */
+
+   std::string getColor() const;
+
+/*
+ * Method: scale
+ * Usage: gobj->scale(sf);
+ *        gobj->scale(sx, sy);
+ * ---------------------------
+ * Scales the object by the specified scale factors.  Most clients will use
+ * the first form, which scales the object by <code>sf</code> in both
+ * dimensions, so that invoking <code>gobj->scale(2)</code> doubles the
+ * size of the object.  The second form applies independent scale factors
+ * to the <i>x</i> and <i>y</i> dimensions.
+ */
+
+   void scale(double sf);
+   void scale(double sx, double sy);
+
+/*
+ * Method: rotate
+ * Usage: gobj->rotate(theta);
+ * ---------------------------
+ * Transforms the object by rotating it <code>theta</code> degrees
+ * counterclockwise around its origin.
+ */
+
+   void rotate(double theta);
+
+/*
+ * Method: setVisible
+ * Usage: gobj->setVisible(flag);
+ * ------------------------------
+ * Sets whether this object is visible.
+ */
+
+   void setVisible(bool flag);
+
+/*
+ * Method: isVisible
+ * Usage: if (gobj->isVisible()) ...
+ * ---------------------------------
+ * Returns <code>true</code> if this object is visible.
+ */
+
+   bool isVisible() const;
+
+/*
+ * Method: sendForward
+ * Usage: gobj->sendForward();
+ * ---------------------------
+ * Moves this object one step toward the front in the <i>z</i> dimension.
+ * If it was already at the front of the stack, nothing happens.
+ */
+
+   void sendForward();
+
+/*
+ * Method: sendToFront
+ * Usage: gobj->sendToFront();
+ * ---------------------------
+ * Moves this object to the front of the display in the <i>z</i> dimension.
+ * By moving it to the front, this object will appear to be on top of the
+ * other graphical objects on the display and may hide any objects that
+ * are further back.
+ */
+
+   void sendToFront();
+
+/*
+ * Method: sendBackward
+ * Usage: gobj->sendBackward();
+ * ----------------------------
+ * Moves this object one step toward the back in the <i>z</i> dimension.
+ * If it was already at the back of the stack, nothing happens.
+ */
+
+   void sendBackward();
+
+/*
+ * Method: sendToBack
+ * Usage: gobj->sendToBack();
+ * --------------------------
+ * Moves this object to the back of the display in the <i>z</i> dimension.
+ * By moving it to the back, this object will appear to be behind the other
+ * graphical objects on the display and may be obscured by other objects
+ * in front.
+ */
+
+   void sendToBack();
+
+/*
+ * Method: contains
+ * Usage: if (gobj->contains(pt)) ...
+ *        if (gobj->contains(x, y)) ...
+ * ------------------------------------
+ * Returns <code>true</code> if the specified point is inside the object.
+ */
+
+   bool contains(GPoint pt) const;
+   virtual bool contains(double x, double y) const;
+
+/*
+ * Method: getType
+ * Usage: string type = gobj->getType();
+ * -------------------------------------
+ * Returns the concrete type of the object as a string, as in
+ * <code>"GOval"</code> or <code>"GRect"</code>.
+ */
+
+   virtual std::string getType() const = 0;
+
+/*
+ * Method: toString
+ * Usage: gobj->toString();
+ * ------------------------
+ * Returns a printable representation of the object.
+ */
+
+   virtual std::string toString() const = 0;
+
+/*
+ * Method: getParent
+ * Usage: GCompound *parent = gobj->getParent();
+ * ---------------------------------------------
+ * Returns a pointer to the <code>GCompound</code> that contains this
+ * object.  Every <code>GWindow</code> is initialized to contain a single
+ * <code>GCompound</code> that is aligned with the window.  Adding
+ * objects to the window adds them to that <code>GCompound</code>,
+ * which means that every object you add to the window has a parent.
+ * Calling <code>getParent</code> on the top-level <code>GCompound</code>
+ * returns <code>NULL</code>.
+ */
+
+   GCompound *getParent() const;
+
+/* Private section */
+
+private:
+   const GObject & operator=(const GObject &) { return *this; }
+   GObject(const GObject &) { }
+
+/* Instance variables */
+
+protected:
+   double x;                       /* The x coordinate of the origin     */
+   double y;                       /* The y coordinate of the origin     */
+   double lineWidth;               /* The width of the line in pixels    */
+   std::string color;              /* The color of the object            */
+   bool visible;                   /* Indicates if object is visible     */
+   bool transformed;               /* Indicates if object is transformed */
+   GCompound *parent;              /* Pointer to the parent              */
+
+protected:
+   GObject();
+
+   friend class GArc;
+   friend class GButton;
+   friend class GCheckBox;
+   friend class GChooser;
+   friend class GCompound;
+   friend class GImage;
+   friend class GInteractor;
+   friend class GLabel;
+   friend class GLine;
+   friend class GOval;
+   friend class GPolygon;
+   friend class GRect;
+   friend class GRoundRect;
+   friend class GSlider;
+   friend class GTextField;
+   friend class G3DRect;
+
+};
+
+/*
+ * Class: GRect
+ * ------------
+ * This class represents a graphical object whose appearance consists of
+ * a rectangular box.  For example, the following code adds a filled, red
+ * <nobr>200<font class=sansserif size=-1>x</font>100</nobr> rectangle
+ * at the upper left corner of the graphics window:
+ *
+ *<pre>
+ *    int main() {
+ *       GWindow gw;
+ *       cout << "This program draws a red rectangle at (0, 0)." << endl;
+ *       GRect *rect = new GRect(0, 0, 200, 100);
+ *       rect->setFilled(true);
+ *       rect->setColor("RED");
+ *       gw.add(rect);
+ *       return 0;
+ *    }
+ *</pre>
+ */
+
+class GRect : public GObject {
+
+public:
+
+/*
+ * Constructor: GRect
+ * Usage: GRect *rect = new GRect(width, height);
+ *        GRect *rect = new GRect(x, y, width, height);
+ * ----------------------------------------------------
+ * Constructs a rectangle with the specified width and height.  The first
+ * form is positioned at the origin; the second at the coordinates
+ * given by <code>x</code> and <code>y</code>.
+ */
+
+   GRect(double width, double height);
+   GRect(double x, double y, double width, double height);
+
+/*
+ * Destructor: ~GRect
+ * ------------------
+ * Frees any resources maintained by this object.
+ */
+
+   virtual ~GRect();
+
+/*
+ * Method: setSize
+ * Usage: rect->setSize(size);
+ *        rect->setSize(width, height);
+ * ------------------------------------
+ * Changes the size of this rectangle to the specified width and height.
+ */
+
+   void setSize(const GDimension & size);
+   void setSize(double width, double height);
+
+/*
+ * Method: setBounds
+ * Usage: rect->setBounds(rect);
+ *        rect->setBounds(x, y, width, height);
+ * --------------------------------------------
+ * Changes the bounds of this rectangle to the specified values.
+ */
+
+   void setBounds(const GRectangle & size);
+   void setBounds(double x, double y, double width, double height);
+
+/*
+ * Method: setFilled
+ * Usage: rect->setFilled(flag);
+ * -----------------------------
+ * Sets the fill status for the rectangle, where <code>false</code> is
+ * outlined and <code>true</code> is filled.
+ */
+
+   void setFilled(bool flag);
+
+/*
+ * Method: isFilled
+ * Usage: if (rect->isFilled()) ...
+ * --------------------------------
+ * Returns <code>true</code> if the rectangle is filled.
+ */
+
+   bool isFilled() const;
+
+/*
+ * Method: setFillColor
+ * Usage: rect->setFillColor(color);
+ * ---------------------------------
+ * Sets the color used to display the filled region of this rectangle.
+ */
+
+   void setFillColor(std::string color);
+   void setFillColor(int rgb);
+
+/*
+ * Method: getFillColor
+ * Usage: string color = rect->getFillColor();
+ * -------------------------------------------
+ * Returns the color used to display the filled region of this rectangle.  If
+ * none has been set, <code>getFillColor</code> returns the empty string.
+ */
+
+   std::string getFillColor() const;
+
+/* Prototypes for the virtual methods */
+
+   virtual GRectangle getBounds() const;
+   virtual std::string getType() const;
+   virtual std::string toString() const;
+
+protected:
+
+/* Instance variables */
+
+   double width;           /* The width of the rectangle              */
+   double height;          /* The height of the rectangle             */
+   bool fillFlag;          /* Indicates whether the object is filled  */
+   std::string fillColor;  /* Color used to fill the object           */
+
+/* Protected methods */
+
+   GRect();
+   virtual void createGRect(double width, double height);
+
+};
+
+/*
+ * Class: GRoundRect
+ * -----------------
+ * This class represents a graphical object whose appearance consists
+ * of a rectangular box with rounded corners.
+ */
+
+class GRoundRect : public GRect {
+
+public:
+
+/*
+ * Constructor: GRoundRect
+ * Usage: GRoundRect *rect = new GRoundRect(width, height);
+ *        GRoundRect *rect = new GRoundRect(width, height, corner);
+ *        GRoundRect *rect = new GRoundRect(x, y, width, height);
+ *        GRoundRect *rect = new GRoundRect(x, y, width, height, corner);
+ * ----------------------------------------------------------------------
+ * Constructs a new rectangle with the specified width and height.  If
+ * the <code>x</code> and <code>y</code> parameters are specified, they
+ * are used to specify the origin.  The <code>corner</code> parameter
+ * specifies the diameter of the arc forming the corner.
+ */
+
+   GRoundRect(double width, double height);
+   GRoundRect(double width, double height, double corner);
+   GRoundRect(double x, double y, double width, double height);
+   GRoundRect(double x, double y, double width, double height, double corner);
+
+/*
+ * Destructor: ~GRoundRect
+ * -----------------------
+ * Frees any resources maintained by this object.
+ */
+
+   virtual ~GRoundRect();
+
+/* Prototypes for the virtual methods */
+
+   virtual std::string getType() const;
+   virtual std::string toString() const;
+
+protected:
+
+   double corner;
+
+/* Protected methods */
+
+   void createGRoundRect(double width, double height, double corner);
+
+};
+
+/*
+ * Class: G3DRect
+ * --------------
+ * This graphical object subclass represents a rectangular box that can
+ * be raised or lowered.
+ */
+
+class G3DRect : public GRect {
+
+public:
+
+/*
+ * Constructor: G3DRect
+ * Usage: G3DRect *rect = new G3DRect(width, height);
+ *        G3DRect *rect = new G3DRect(width, height, raised);
+ *        G3DRect *rect = new G3DRect(x, y, width, height);
+ *        G3DRect *rect = new G3DRect(x, y, width, height, raised);
+ * ----------------------------------------------------------------
+ * Constructs a new 3D rectangle with the specified width and height.  If
+ * the <code>x</code> and <code>y</code> parameters are specified, they
+ * are used to specify the origin.  The <code>raised</code> parameter
+ * determines whether the rectangle should be drawn with highlights that
+ * suggest that it is raised about the background.
+ */
+
+   G3DRect(double width, double height);
+   G3DRect(double width, double height, bool raised);
+   G3DRect(double x, double y, double width, double height);
+   G3DRect(double x, double y, double width, double height, bool raised);
+
+/*
+ * Destructor: ~G3DRect
+ * --------------------
+ * Frees any resources maintained by this object.
+ */
+
+   virtual ~G3DRect();
+
+/*
+ * Method: setRaised
+ * Usage: rect->setRaised(raised);
+ * -------------------------------
+ * Indicates whether this object appears raised.
+ */
+
+   void setRaised(bool raised);
+
+/*
+ * Method: isRaised
+ * Usage: if (rect->isRaised()) ...
+ * --------------------------------
+ * Returns <code>true</code> if this object appears raised.
+ */
+
+   bool isRaised() const;
+
+/* Prototypes for the virtual methods */
+
+   virtual std::string getType() const;
+   virtual std::string toString() const;
+
+protected:
+
+   bool raised;
+
+/* Protected methods */
+
+   void createG3DRect(double width, double height, bool raised);
+
+};
+
+/*
+ * Class: GOval
+ * ------------
+ * This graphical object subclass represents an oval inscribed in
+ * a rectangular box.  For example, the following code displays a
+ * filled green oval inscribed in the graphics window:
+ *
+ *<pre>
+ *    int main() {
+ *       GWindow gw;
+ *       cout << "This program draws a green oval filling the window." << endl;
+ *       GOval *oval = new GOval(gw.getWidth(), gw.getHeight());
+ *       oval->setFilled(true);
+ *       oval->setColor("GREEN");
+ *       gw.add(oval);
+ *       return 0;
+ *    }
+ *</pre>
+ */
+
+class GOval : public GObject {
+
+public:
+
+/*
+ * Constructor: GOval
+ * Usage: GOval *oval = new GOval(width, height);
+ *        GOval *oval = new GOval(x, y, width, height);
+ * ----------------------------------------------------
+ * Constructs a new oval inscribed in the specified rectangle.  The
+ * first form is positioned at the origin; the second at the coordinates
+ * given by <code>x</code> and <code>y</code>.
+ */
+
+   GOval(double width, double height);
+   GOval(double x, double y, double width, double height);
+
+/*
+ * Destructor: ~GOval
+ * ------------------
+ * Frees any resources maintained by this object.
+ */
+
+   virtual ~GOval();
+
+/*
+ * Method: setSize
+ * Usage: oval->setSize(size);
+ *        oval->setSize(width, height);
+ * ------------------------------------
+ * Changes the size of the bounding rectangle to the specified width
+ * and height.
+ */
+
+   void setSize(const GDimension & size);
+   void setSize(double width, double height);
+
+/*
+ * Method: setBounds
+ * Usage: oval->setBounds(rect);
+ *        oval->setBounds(x, y, width, height);
+ * --------------------------------------------
+ * Changes the bounds of the oval to the specified values.
+ */
+
+   void setBounds(const GRectangle & size);
+   void setBounds(double x, double y, double width, double height);
+
+/*
+ * Method: setFilled
+ * Usage: oval->setFilled(flag);
+ * -----------------------------
+ * Sets the fill status for the oval, where <code>false</code> is
+ * outlined and <code>true</code> is filled.
+ */
+
+   void setFilled(bool flag);
+
+/*
+ * Method: isFilled
+ * Usage: if (oval->isFilled()) ...
+ * --------------------------------
+ * Returns <code>true</code> if the oval is filled.
+ */
+
+   bool isFilled() const;
+
+/*
+ * Method: setFillColor
+ * Usage: oval->setFillColor(color);
+ * ---------------------------------
+ * Sets the color used to display the filled region of this oval.
+ */
+
+   void setFillColor(std::string color);
+   void setFillColor(int rgb);
+
+/*
+ * Method: getFillColor
+ * Usage: string color = oval->getFillColor();
+ * -------------------------------------------
+ * Returns the color used to display the filled region of this oval.  If
+ * none has been set, <code>getFillColor</code> returns the empty string.
+ */
+
+   std::string getFillColor() const;
+
+/* Prototypes for the virtual methods */
+
+   virtual GRectangle getBounds() const;
+   virtual bool contains(double x, double y) const;
+   virtual std::string getType() const;
+   virtual std::string toString() const;
+
+protected:
+
+/* Instance variables */
+
+   double width;           /* The width of the bounding rectangle     */
+   double height;          /* The height of the bounding rectangle    */
+   bool fillFlag;          /* Indicates whether the object is filled  */
+   std::string fillColor;  /* Color used to fill the object           */
+
+/* Protected methods */
+
+   void createGOval(double width, double height);
+
+};
+
+/*
+ * Class: GArc
+ * -----------
+ * This graphical object subclass represents an elliptical arc.  The
+ * arc is specified by the following parameters:
+ *
+ * <p><ul>
+ *   <li>The coordinates of the bounding rectangle (<code>x</code>,
+ *       <code>y</code>, <code>width</code>, <code>height</code>)
+ *   <li>The angle at which the arc starts (<code>start</code>)
+ *   <li>The number of degrees that the arc covers (<code>sweep</code>)
+ * </ul>
+ *
+ * <p>All angles in a <code>GArc</code> description are measured in
+ * degrees moving counterclockwise from the +<i>x</i> axis.  Negative
+ * values for either <code>start</code> or <code>sweep</code> indicate
+ * motion in a clockwise direction.
+ * <include src="pictures/GObjectDiagrams/GArcGeometry.html">
+ */
+
+class GArc : public GObject {
+
+public:
+
+/*
+ * Constructor: GArc
+ * Usage: GArc *arc = new GArc(width, height, start, sweep);
+ *        GArc *arc = new GArc(x, y, width, height, start, sweep);
+ * ---------------------------------------------------------------
+ * Creates a new <code>GArc</code> object consisting of an elliptical arc.
+ * The first form creates a <code>GArc</code> whose origin is the point
+ * (0,&nbsp;0); the second form positions the <code>GArc</code> at the
+ * point (<code>x</code>, <code>y</code>).
+ * <include src="pictures/GObjectDiagrams/GArcExamples.html">
+ */
+
+   GArc(double width, double height, double start, double sweep);
+   GArc(double x, double y, double width, double height,
+                            double start, double sweep);
+
+/*
+ * Method: setStartAngle
+ * Usage: arc->setStartAngle(start);
+ * ---------------------------------
+ * Sets the starting angle for this <code>GArc</code> object.
+ */
+
+   void setStartAngle(double start);
+
+/*
+ * Method: getStartAngle
+ * Usage: double angle = arc->getStartAngle();
+ * -------------------------------------------
+ * Returns the starting angle for this <code>GArc</code> object.
+ */
+
+   double getStartAngle() const;
+
+/*
+ * Method: setSweepAngle
+ * Usage: arc->setSweepAngle(start);
+ * ---------------------------------
+ * Sets the sweep angle for this <code>GArc</code> object.
+ */
+
+   void setSweepAngle(double start);
+
+/*
+ * Method: getSweepAngle
+ * Usage: double angle = arc->getSweepAngle();
+ * -------------------------------------------
+ * Returns the sweep angle for this <code>GArc</code> object.
+ */
+
+   double getSweepAngle() const;
+
+/*
+ * Method: getStartPoint
+ * Usage: GPoint pt = arc->getStartPoint();
+ * ----------------------------------------
+ * Returns the point at which the arc starts.
+ */
+
+   GPoint getStartPoint() const;
+
+/*
+ * Method: getEndPoint
+ * Usage: GPoint pt = arc->getEndPoint();
+ * --------------------------------------
+ * Returns the point at which the arc ends.
+ */
+
+   GPoint getEndPoint() const;
+
+/*
+ * Method: setFrameRectangle
+ * Usage: arc->setFrameRectangle(rect);
+ *        arc->setFrameRectangle(x, y, width, height);
+ * ---------------------------------------------------
+ * Changes the boundaries of the rectangle used to frame the arc.
+ */
+
+   void setFrameRectangle(const GRectangle & rect);
+   void setFrameRectangle(double x, double y, double width, double height);
+
+/*
+ * Method: getFrameRectangle
+ * Usage: GRectangle rect = arc->getFrameRectangle();
+ * --------------------------------------------------
+ * Returns the boundaries of the rectangle used to frame the arc.
+ */
+
+   GRectangle getFrameRectangle() const;
+
+/*
+ * Method: setFilled
+ * Usage: arc->setFilled(flag);
+ * ----------------------------
+ * Sets the fill status for the arc, where <code>false</code> is
+ * outlined and <code>true</code> is filled.  If a <code>GArc</code> is
+ * unfilled, the figure consists only of the arc itself.  If a
+ * <code>GArc</code> is filled, the figure consists of the
+ * pie-shaped wedge formed by connecting the endpoints of the arc to
+ * the center.  As an example, the following program draws a 270-degree
+ * arc starting at 45 degrees, filled in yellow, much like the character
+ * in the PacMan video game:
+ *
+ *<pre>
+ *    int main() {
+ *       GWindow gw;
+ *       cout << "This program draws the PacMan character." << endl;
+ *       double cx = gw.getWidth() / 2;
+ *       double cy = gw.getHeight() / 2;
+ *       double r = 25;
+ *       GArc *pacman = new GArc(cx - r, cy - r, 2 * r, 2 * r, 45, 270);
+ *       pacman->setFilled(true);
+ *       pacman->setFillColor("YELLOW");
+ *       gw.add(pacman);
+ *       return 0;
+ *    }
+ *</pre>
+ * <include src="pictures/GObjectDiagrams/PacMan.html">
+ */
+
+   void setFilled(bool flag);
+
+/*
+ * Method: isFilled
+ * Usage: if (arc->isFilled()) ...
+ * -------------------------------
+ * Returns <code>true</code> if the arc is filled.
+ */
+
+   bool isFilled() const;
+
+/*
+ * Method: setFillColor
+ * Usage: arc->setFillColor(color);
+ * --------------------------------
+ * Sets the color used to display the filled region of this arc.
+ * Colors are specified as strings as described in the notes for the
+ * <a href="GObject-class.html#Method:setColor"><code>setColor</code></a>
+ * method.
+ */
+
+   void setFillColor(std::string color);
+   void setFillColor(int rgb);
+
+/*
+ * Method: getFillColor
+ * Usage: string color = arc->getFillColor();
+ * ------------------------------------------
+ * Returns the color used to display the filled region of this arc.  If
+ * none has been set, <code>getFillColor</code> returns the empty string.
+ */
+
+   std::string getFillColor() const;
+
+/* Prototypes for the virtual methods */
+
+   virtual GRectangle getBounds() const;
+   virtual bool contains(double x, double y) const;
+   virtual std::string getType() const;
+   virtual std::string toString() const;
+
+private:
+
+   GPoint getArcPoint(double theta) const;
+   bool containsAngle(double theta) const;
+   void createGArc(double width, double height, double start, double sweep);
+
+/* Instance variables */
+
+   double start;                   /* Starting angle of the arc       */
+   double sweep;                   /* How many degrees the arc runs   */
+   double frameWidth;              /* The width of the bounding box   */
+   double frameHeight;             /* The height of the bounding box  */
+   std::string fillColor;          /* The color of the interior       */
+   bool fillFlag;                  /* Indicates if the arc is filled  */
+
+};
+
+/*
+ * Class: GCompound
+ * ----------------
+ * This graphical object subclass consists of a collection
+ * of other graphical objects.  Once assembled, the internal objects
+ * can be manipulated as a unit.  The <code>GCompound</code> keeps
+ * track of its own position, and all items within it are drawn
+ * relative to that location.
+ */
+
+class GCompound : public GObject {
+
+public:
+
+/*
+ * Constructor: GCompound
+ * Usage: GCompound *comp = new GCompound();
+ * -----------------------------------------
+ * Creates a <code>GCompound</code> object with no internal components.
+ */
+
+   GCompound();
+
+/*
+ * Method: add
+ * Usage: comp->add(gobj);
+ *        comp->add(gobj, x, y);
+ * -----------------------------
+ * Adds a new graphical object to the <code>GCompound</code>.  The second
+ * form moves the object to the point (<code>x</code>, <code>y</code>) first.
+ */
+
+   void add(GObject *gobj);
+   void add(GObject *gobj, double x, double y);
+
+/*
+ * Method: remove
+ * Usage: comp->remove(gobj);
+ * --------------------------
+ * Removes the specified object from the <code>GCompound</code>.
+ */
+
+   void remove(GObject *gobj);
+
+/*
+ * Method: removeAll
+ * Usage: comp->removeAll();
+ * -------------------------
+ * Removes all graphical objects from the <code>GCompound</code>.
+ */
+
+   void removeAll();
+
+/*
+ * Method: getElementCount
+ * Usage: int n = comp->getElementCount();
+ * ---------------------------------------
+ * Returns the number of graphical objects stored in the
+ * <code>GCompound</code>.
+ */
+
+   int getElementCount();
+
+/*
+ * Method: getElement
+ * Usage: GObject *gobj = comp->getElement(index);
+ * -----------------------------------------------
+ * Returns a pointer to the graphical object at the specified index,
+ * numbering from back to front in the the <i>z</i> dimension.
+ */
+
+   GObject *getElement(int index);
+
+/* Prototypes for the virtual methods */
+
+   virtual GRectangle getBounds() const;
+   virtual bool contains(double x, double y) const;
+   virtual std::string getType() const;
+   virtual std::string toString() const;
+
+private:
+   void sendForward(GObject *gobj);
+   void sendToFront(GObject *gobj);
+   void sendBackward(GObject *gobj);
+   void sendToBack(GObject *gobj);
+   int findGObject(GObject *gobj);
+   void removeAt(int index);
+
+/* Instance variables */
+
+   Vector<GObject *> contents;
+
+/* Friend declarations */
+
+   friend class GObject;
+
+};
+
+/*
+ * Class: GImage
+ * -------------
+ * This graphical object subclass represents an image from a file.
+ * For example, the following code displays a <code>GImage</code>
+ * containing the Stanford tree at the center of the window, assuming
+ * that the image file <code>StanfordTree.png</code> exists, either in
+ * the current directory or an <code>images</code> subdirectory:
+ *
+ *<pre>
+ *    int main() {
+ *       GWindow gw;
+ *       cout << "This program draws the Stanford tree." << endl;
+ *       GImage *tree = new GImage("StanfordTree.png");
+ *       double x = (gw.getWidth() - tree->getWidth()) / 2;
+ *       double y = (gw.getHeight() - tree->getHeight()) / 2;
+ *       gw.add(tree, x, y);
+ *       return 0;
+ *    }
+ *</pre>
+ */
+
+class GImage : public GObject {
+
+public:
+
+/*
+ * Constructor: GImage
+ * Usage: GImage *image = new GImage(filename);
+ *        GImage *image = new GImage(filename, x, y);
+ * --------------------------------------------------
+ * Constructs a new image by loading the image from the specified
+ * file, which is either in the current directory or a subdirectory named
+ * <code>images</code>.  By default, the upper left corner of the image
+ * appears at the origin; the second form automatically sets the location
+ * to the point (<code>x</code>, <code>y</code>).
+ */
+
+   GImage(std::string filename);
+   GImage(std::string filename, double x, double y);
+
+/* Prototypes for the virtual methods */
+
+   virtual GRectangle getBounds() const;
+   virtual std::string getType() const;
+   virtual std::string toString() const;
+
+private:
+   std::string filename;
+   double width;
+   double height;
+
+   void createGImage(std::string filename);
+
+};
+
+/*
+ * Class: GLabel
+ * -------------
+ * This graphical object subclass represents a text string.  For
+ * example, the following code adds a <code>GLabel</code> containing
+ * the string <code>"hello, world"</code> to the center of the window:
+ *
+ *<pre>
+ *    int main() {
+ *       GWindow gw;
+ *       cout << "This program draws the 'hello, world' message." << endl;
+ *       GLabel *label = new GLabel("hello, world");
+ *       label->setFont("SansSerif-18");
+ *       double x = (gw.getWidth() - label->getWidth()) / 2;
+ *       double y = (gw.getHeight() + label->getFontAscent()) / 2;
+ *       gw.add(label, x, y);
+ *       return 0;
+ *    }
+ *</pre>
+ *
+ * Controlling the appearance and positioning of a <code>GLabel</code>
+ * depends on understanding the following terms:
+ *
+ * <p><ul>
+ *   <li>The <b><i>baseline</i></b> is the horizontal line on which the
+ *       characters rest.
+ *   <li>The <b><i>origin</i></b> is the point on the baseline at which
+ *       the label begins.
+ *   <li>The <b><i>height</i></b> is the distance that separate two
+ *       successive lines.
+ *   <li>The <b><i>ascent</i></b> is the maximum distance a character
+ *       in this font extends above the baseline.
+ *   <li>The <b><i>descent</i></b> is the maximum distance a character
+ *       in this font extends below the baseline.
+ * </ul>
+ * <include src="pictures/GObjectDiagrams/GLabelGeometry.html">
+ */
+
+class GLabel : public GObject {
+
+public:
+
+/*
+ * Constructor: GLabel
+ * Usage: GLabel *label = new GLabel(str);
+ *        GLabel *label = new GLabel(str, x, y);
+ * ---------------------------------------------
+ * Creates a <code>GLabel</code> object containing the specified string.
+ * By default, the baseline of the first character appears at the origin;
+ * the second form automatically resets the location of the
+ * <code>GLabel</code> to the point (<code>x</code>, <code>y</code>).
+ */
+
+   GLabel(std::string str);
+   GLabel(std::string str, double x, double y);
+
+/*
+ * Method: setFont
+ * Usage: label->setFont(font);
+ * ----------------------------
+ * Changes the font used to display the <code>GLabel</code> as specified by
+ * the string <code>font</code>, which has the following format:
+ *
+ *<pre>
+ *    family-style-size
+ *</pre>
+ *
+ * where both <code>style</code> and <code>size</code> are optional.
+ * If any of these elements are missing or specified as an asterisk,
+ * the existing value is retained.
+ */
+
+   void setFont(std::string font);
+
+/*
+ * Method: getFont
+ * Usage: string font = label->getFont();
+ * --------------------------------------
+ * Returns the current font for the <code>GLabel</code>.
+ */
+
+   std::string getFont() const;
+
+/*
+ * Method: setLabel
+ * Usage: label->setLabel(str);
+ * ----------------------------
+ * Changes the string stored within the <code>GLabel</code> object, so that
+ * a new text string appears on the display.
+ */
+
+   void setLabel(std::string str);
+
+/*
+ * Method: getLabel
+ * Usage: string str = label->getLabel();
+ * --------------------------------------
+ * Returns the string displayed by this object.
+ */
+
+   std::string getLabel() const;
+
+/*
+ * Method: getFontAscent
+ * Usage: double ascent = label->getFontAscent();
+ * ----------------------------------------------
+ * Returns the maximum distance strings in this font extend above
+ * the baseline.
+ */
+
+   double getFontAscent() const;
+
+/*
+ * Method: getFontDescent
+ * Usage: double descent = label->getFontDescent();
+ * ------------------------------------------------
+ * Returns the maximum distance strings in this font descend below
+ * the baseline.
+ */
+
+   double getFontDescent() const;
+
+/* Prototypes for the virtual methods */
+
+   virtual GRectangle getBounds() const;
+   virtual std::string getType() const;
+   virtual std::string toString() const;
+
+private:
+
+/* Instance variables */
+
+   std::string str;                /* The string displayed by the label */
+   std::string font;               /* The font string of the label      */
+   double width;                   /* Width of the bounding box         */
+   double height;                  /* Height of the bounding box        */
+   double ascent;                  /* Font ascent                       */
+   double descent;                 /* Font descent                      */
+
+   void createGLabel(const std::string & str);
+
+};
+
+/*
+ * Class: GLine
+ * ------------
+ * This graphical object subclass represents a line segment.  For
+ * example, the following code adds lines that mark the diagonals
+ * of the graphics window:
+ *
+ *<pre>
+ *    int main() {
+ *       GWindow gw;
+ *       cout << "This program draws the diagonals on the window." << endl;
+ *       gw.add(new GLine(0, 0, gw.getWidth(), gw.getHeight()));
+ *       gw.add(new GLine(0, gw.getHeight(), gw.getWidth(), 0));
+ *       return 0;
+ *    }
+ *</pre>
+ */
+
+class GLine : public GObject {
+
+public:
+
+/*
+ * Constructor: GLine
+ * Usage: GLine *gline = new GLine(x0, y0, x1, y1);
+ * ------------------------------------------------
+ * Constructs a line segment from its endpoints.  The point
+ * (<code>x0</code>,&nbsp;<code>y0</code>) defines the start of the
+ * line and the point (<code>x1</code>,&nbsp;<code>y1</code>) defines
+ * the end.
+ */
+
+   GLine(double x0, double y0, double x1, double y1);
+
+/*
+ * Method: setStartPoint
+ * Usage: line->setStartPoint(x, y);
+ * ---------------------------------
+ * Sets the initial point in the line to (<code>x</code>,&nbsp;<code>y</code>),
+ * leaving the end point unchanged.  This method is therefore different from
+ * <code>setLocation</code>, which moves both components of the line segment.
+ */
+
+   void setStartPoint(double x, double y);
+
+/*
+ * Method: getStartPoint
+ * Usage: GPoint pt = line->getStartPoint();
+ * -----------------------------------------
+ * Returns the point at which the line starts.
+ */
+
+   GPoint getStartPoint() const;
+
+/*
+ * Method: setEndPoint
+ * Usage: line->setEndPoint(x, y);
+ * -------------------------------
+ * Sets the end point in the line to (<code>x</code>,&nbsp;<code>y</code>),
+ * leaving the start point unchanged.  This method is therefore different from
+ * <code>setLocation</code>, which moves both components of the line segment.
+ */
+
+   void setEndPoint(double x, double y);
+
+/*
+ * Method: getEndPoint
+ * Usage: GPoint pt = line->getEndPoint();
+ * ---------------------------------------
+ * Returns the point at which the line ends.
+ */
+
+   GPoint getEndPoint() const;
+
+/* Prototypes for the virtual methods */
+
+   virtual GRectangle getBounds() const;
+   virtual bool contains(double x, double y) const;
+   virtual std::string getType() const;
+   virtual std::string toString() const;
+
+protected:
+
+/* Instance variables */
+
+   double dx;                   /* The x displacement of the line */
+   double dy;                   /* The y displacement of the line */
+
+};
+
+/*
+ * Class: GPolygon
+ * ---------------
+ * This graphical object subclass represents a polygon bounded by
+ * line segments.  The <code>GPolygon</code> constructor creates an
+ * empty polygon.  To complete the figure, you need to add vertices
+ * to the polygon using the methods
+ * <a href="#Method:addVertex"><code>addVertex</code></a>,
+ * <a href="#Method:addEdge"><code>addEdge</code></a>,
+ * and <a href="#Method:addPolarEdge"><code>addPolarEdge</code></a>.
+ * As an example, the following code adds a filled red octagon to
+ * the center of the window:
+ *
+ *<pre>
+ *    int main() {
+ *       GWindow gw;
+ *       cout << "This program draws a red octagon." << endl;
+ *       double edge = 75;
+ *       GPolygon *stopSign = new GPolygon();
+ *       stopSign->addVertex(-edge / 2, edge / 2 + edge / sqrt(2.0));
+ *       for (int i = 0; i < 8; i++) {
+ *          stopSign->addPolarEdge(edge, 45 * i);
+ *       }
+ *       stopSign->setFilled(true);
+ *       stopSign->setColor("RED");
+ *       gw.add(stopSign, gw.getWidth() / 2, gw.getHeight() / 2);
+ *       return 0;
+ *    }
+ *</pre>
+ * <include src="pictures/GObjectDiagrams/StopSign.html">
+ */
+
+class GPolygon : public GObject {
+
+public:
+
+/*
+ * Constructor: GPolygon
+ * Usage: GPolygon *poly = new GPolygon();
+ * ---------------------------------------
+ * Constructs a new empty polygon at the origin.
+ */
+
+   GPolygon();
+
+/*
+ * Method: addVertex
+ * Usage: poly->addVertex(x, y);
+ * -----------------------------
+ * Adds a vertex at (<code>x</code>, <code>y</code>) relative to the polygon
+ * origin.
+ */
+
+   void addVertex(double x, double y);
+
+/*
+ * Method: addEdge
+ * Usage: poly->addEdge(dx, dy);
+ * -----------------------------
+ * Adds an edge to the polygon whose components are given by the displacements
+ * <code>dx</code> and <code>dy</code> from the last vertex.
+ */
+
+   void addEdge(double dx, double dy);
+
+/*
+ * Method: addPolarEdge
+ * Usage: poly->addPolarEdge(r, theta);
+ * ------------------------------------
+ * Adds an edge to the polygon specified in polar coordinates.  The length
+ * of the edge is given by <code>r</code>, and the edge extends in
+ * direction <code>theta</code>, measured in degrees counterclockwise
+ * from the +x axis.
+ */
+
+   void addPolarEdge(double r, double theta);
+
+/*
+ * Method: getVertices
+ * Usage: Vector<GPoint> vec = poly->getVertices();
+ * ------------------------------------------------
+ * Returns a vector of the points in the polygon.
+ */
+
+   Vector<GPoint> getVertices() const;
+
+/*
+ * Method: setFilled
+ * Usage: poly->setFilled(flag);
+ * -----------------------------
+ * Sets the fill status for the polygon, where <code>false</code> is
+ * outlined and <code>true</code> is filled.
+ */
+
+   void setFilled(bool flag);
+
+/*
+ * Method: isFilled
+ * Usage: if (poly->isFilled()) ...
+ * --------------------------------
+ * Returns <code>true</code> if the polygon is filled.
+ */
+
+   bool isFilled() const;
+
+/*
+ * Method: setFillColor
+ * Usage: poly->setFillColor(color);
+ * ---------------------------------
+ * Sets the color used to display the filled region of this polygon.
+ */
+
+   void setFillColor(std::string color);
+   void setFillColor(int rgb);
+
+/*
+ * Method: getFillColor
+ * Usage: string color = poly->getFillColor();
+ * -------------------------------------------
+ * Returns the color used to display the filled region of this polygon.  If
+ * none has been set, <code>getFillColor</code> returns the empty string.
+ */
+
+   std::string getFillColor() const;
+
+/* Prototypes for the virtual methods */
+
+   virtual GRectangle getBounds() const;
+   virtual bool contains(double x, double y) const;
+   virtual std::string getType() const;
+   virtual std::string toString() const;
+
+private:
+
+/* Instance variables */
+
+   Vector<GPoint> vertices;        /* The vertices of the polygon   */
+   double cx;                      /* The most recent x coordinate  */
+   double cy;                      /* The most recent y coordinate  */
+   std::string fillColor;          /* The color of the interior     */
+   bool fillFlag;                  /* Indicates if object is filled */
+
+};
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/graph.h b/labb8/lib/StanfordCPPLib/graph.h
new file mode 100755
index 0000000..30fae8f
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/graph.h
@@ -0,0 +1,836 @@
+/*
+ * File: graph.h
+ * -------------
+ * This file exports a parameterized <code>Graph</code> class used
+ * to represent <b><i>graphs,</i></b> which consist of a set of
+ * <b><i>nodes</i></b> and a set of <b><i>arcs</i></b>.
+ */
+
+#ifndef _graph_h
+#define _graph_h
+
+#include <string>
+#include "map.h"
+#include "set.h"
+#include "tokenscanner.h"
+
+/*
+ * Class: Graph<NodeType,ArcType>
+ * ------------------------------
+ * This class represents a graph with the specified node and arc types.
+ * The <code>NodeType</code> and <code>ArcType</code> parameters indicate
+ * the structure type or class used for nodes and arcs, respectively.
+ * These types can contain any fields or methods required by the client,
+ * but must contain the following fields required by the <code>Graph</code>
+ * package itself:
+ *
+ * <p>The <code>NodeType</code> definition must include:
+ * <ul>
+ *   <li>A <code>string</code> field called <code>name</code>
+ *   <li>A <code>Set&lt;ArcType *&gt;</code> field called <code>arcs</code>
+ * </ul>
+ *
+ * <p>The <code>ArcType</code> definition must include:
+ * <ul>
+ *   <li>A <code>NodeType *</code> field called <code>start</code>
+ *   <li>A <code>NodeType *</code> field called <code>finish</code>
+ * </ul>
+ */
+
+template <typename NodeType,typename ArcType>
+class Graph {
+
+public:
+
+/*
+ * Constructor: Graph
+ * Usage: Graph<NodeType,ArcType> g;
+ * ---------------------------------
+ * Creates an empty <code>Graph</code> object.
+ */
+
+   Graph();
+
+/*
+ * Destructor: ~Graph
+ * ------------------
+ * Frees the internal storage allocated to represent the graph.
+ */
+
+   virtual ~Graph();
+
+/*
+ * Method: size
+ * Usage: int size = g.size();
+ * ---------------------------
+ * Returns the number of nodes in the graph.
+ */
+
+   int size() const;
+
+/*
+ * Method: isEmpty
+ * Usage: if (g.isEmpty()) ...
+ * ---------------------------
+ * Returns <code>true</code> if the graph is empty.
+ */
+
+   bool isEmpty() const;
+
+/*
+ * Method: clear
+ * Usage: g.clear();
+ * -----------------
+ * Reinitializes the graph to be empty, freeing any heap storage.
+ */
+
+   void clear();
+
+/*
+ * Method: addNode
+ * Usage: NodeType *node = g.addNode(name);
+ *        NodeType *node = g.addNode(node);
+ * ----------------------------------------
+ * Adds a node to the graph.  The first version of this method
+ * creates a new node of the appropriate type and initializes its
+ * fields; the second assumes that the client has already created
+ * the node and simply adds it to the graph.  Both versions of this
+ * method return a pointer to the node.
+ */
+
+   NodeType *addNode(std::string name);
+   NodeType *addNode(NodeType *node);
+
+/*
+ * Method: removeNode
+ * Usage: g.removeNode(name);
+ *        g.removeNode(node);
+ * --------------------------
+ * Removes a node from the graph, where the node can be specified
+ * either by its name or as a pointer value.  Removing a node also
+ * removes all arcs that contain that node.
+ */
+
+   void removeNode(std::string name);
+   void removeNode(NodeType *node);
+
+/*
+ * Method: getNode
+ * Usage: NodeType *node = g.getNode(name);
+ * ----------------------------------------
+ * Looks up a node in the name table attached to the graph and
+ * returns a pointer to that node.  If no node with the specified
+ * name exists, <code>getNode</code> returns <code>NULL</code>.
+ */
+
+   NodeType *getNode(std::string name) const;
+
+/*
+ * Method: addArc
+ * Usage: g.addArc(s1, s2);
+ *        g.addArc(n1, n2);
+ *        g.addArc(arc);
+ * ---------------------
+ * Adds an arc to the graph.  The endpoints of the arc can be specified
+ * either as strings indicating the names of the nodes or as pointers
+ * to the node structures.  Alternatively, the client can create the arc
+ * structure explicitly and pass that pointer to the <code>addArc</code>
+ * method.  All three of these versions return a pointer to the arc in
+ * case the client needs to capture this value.
+ */
+
+   ArcType *addArc(std::string s1, std::string s2);
+   ArcType *addArc(NodeType *n1, NodeType *n2);
+   ArcType *addArc(ArcType *arc);
+
+/*
+ * Method: removeArc
+ * Usage: g.removeArc(s1, s2);
+ *        g.removeArc(n1, n2);
+ *        g.removeArc(arc);
+ * ------------------------
+ * Removes an arc from the graph, where the arc can be specified in any
+ * of three ways: by the names of its endpoints, by the node pointers
+ * at its endpoints, or as an arc pointer.  If more than one arc
+ * connects the specified endpoints, all of them are removed.
+ */
+
+   void removeArc(std::string s1, std::string s2);
+   void removeArc(NodeType *n1, NodeType *n2);
+   void removeArc(ArcType *arc);
+
+/*
+ * Method: isConnected
+ * Usage: if (g.isConnected(n1, n2)) ...
+ *        if (g.isConnected(s1, s2)) ...
+ * -------------------------------------
+ * Returns <code>true</code> if the graph contains an arc from
+ * <code>n1</code> to <code>n2</code>.  As in the <code>addArc</code>
+ * method, nodes can be specified either as node pointers or by name.
+ */
+
+   bool isConnected(NodeType *n1, NodeType *n2) const;
+   bool isConnected(std::string s1, std::string s2) const;
+
+/*
+ * Method: getNodeSet
+ * Usage: foreach (NodeType *node in g.getNodeSet()) ...
+ * -----------------------------------------------------
+ * Returns the set of all nodes in the graph.
+ */
+
+   const Set<NodeType *> & getNodeSet() const;
+
+/*
+ * Method: getArcSet
+ * Usage: foreach (ArcType *arc in g.getArcSet()) ...
+ *        foreach (ArcType *arc in g.getArcSet(node)) ...
+ *        foreach (ArcType *arc in g.getArcSet(name)) ...
+ * ------------------------------------------------------
+ * Returns the set of all arcs in the graph or, in the second and
+ * third forms, the arcs that start at the specified node, which
+ * can be indicated either as a pointer or by name.
+ */
+
+   const Set<ArcType *> & getArcSet() const;
+   const Set<ArcType *> & getArcSet(NodeType *node) const;
+   const Set<ArcType *> & getArcSet(std::string name) const;
+
+/*
+ * Method: getNeighbors
+ * Usage: foreach (NodeType *node in g.getNeighbors(node)) ...
+ *        foreach (NodeType *node in g.getNeighbors(name)) ...
+ * -----------------------------------------------------------
+ * Returns the set of nodes that are neighbors of the specified
+ * node, which can be indicated either as a pointer or by name.
+ */
+
+   const Set<NodeType *> getNeighbors(NodeType *node) const;
+   const Set<NodeType *> getNeighbors(std::string node) const;
+
+/*
+ * Method: toString
+ * Usage: string str = g.toString();
+ * ---------------------------------
+ * Converts the graph to a printable string representation.
+ */
+
+   std::string toString();
+
+/*
+ * Friend method: writeNodeData
+ * Usage: writeNodeData(os, NodeType *node);
+ * -----------------------------------------
+ * Writes the data for the node to the output stream.  The default
+ * implementation of this method is empty.  Clients that want to store
+ * other fields from the node must override this method so that it
+ * writes that data in a form that scanNodeData can read.
+ */
+
+   virtual void writeNodeData(std::ostream &, NodeType *) const {
+      /* Empty */
+   }
+
+/*
+ * Friend method: writeArcData
+ * Usage: writeArcData(os, ArcType *arc);
+ * --------------------------------------
+ * Writes the data for the arc to the output stream.  The default
+ * implementation of this method is empty.  Clients that want to store
+ * other fields from the arc must override this method so that it writes
+ * that data in a form that scanArcData can read.
+ */
+
+   virtual void writeArcData(std::ostream &, ArcType *) const {
+      /* Empty */
+   }
+
+/*
+ * Friend method: scanGraphEntry
+ * Usage: while (g.scanGraphEntry(scanner)) { }
+ * --------------------------------------------
+ * This method reads one "entry" for the graph, which is either a node
+ * description or an arc description.  The <code>scanGraphEntry</code>
+ * method returns <code>true</code> if it reads an entry, and
+ * <code>false</code> at the end of file or at text that cannot be
+ * recognized as a graph entry.
+ *
+ * <p>Node entries consist of the name of a node (which may be quoted
+ * if it contains special characters), optionally followed by data for
+ * the node.  Arc descriptions have one of the following forms:
+ *
+ *<pre>
+ *    n1 -> n2
+ *    n1 - n2
+ *</pre>
+ *
+ * either of which can be followed by data for the arc.  The first form
+ * creates a single directed arc; the second creates two arcs, one in
+ * each direction.
+ *
+ * <p>Clients who want to read node or arc data must override the empty
+ * versions of <code>scanNodeData</code> and <code>scanArcData</code>
+ * included in this interface.
+ */
+
+   virtual bool scanGraphEntry(TokenScanner & scanner);
+
+/*
+ * Friend method: scanNodeData
+ * Usage: scanNodeData(scanner, NodeType *node);
+ * ---------------------------------------------
+ * Reads the data for the specified node from the scanner.  The default
+ * implementation of this method is empty.  Clients that want to initialize
+ * other fields in the node from the token stream must override this method.
+ */
+
+   virtual void scanNodeData(TokenScanner &, NodeType *) {
+      /* Empty */
+   }
+
+/*
+ * Friend method: scanArcData
+ * Usage: scanArcData(scanner, ArcType *forward, ArcType *backward);
+ * -----------------------------------------------------------------
+ * Reads the data for an arc from the scanner.  The <code>forward</code>
+ * argument points to the arc in the forward direction.  If the arc is
+ * undirected, <code>backward</code> points to the reverse arc; for
+ * directed arcs, the <code>backward</code> pointer is <code>NULL</code>.
+ * The default implementation of this method is empty.  Clients that want
+ * to initialize other fields in the arc must override this method so
+ * that it initializes one or both arc, as appropriate.
+ */
+
+   virtual void scanArcData(TokenScanner &, ArcType *, ArcType *) {
+      /* Empty */
+   }
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in the file is logically part    */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+/*
+ * Private class: GraphComparator
+ * ------------------------------
+ * This template class establishes the ordering for nodes and arcs.
+ * Nodes are processed in alphabetical order by node name; arcs are
+ * compared in much the same way, looking first at the start node and
+ * then continuing on to look at the finish node if the start nodes
+ * match.  These functions, however, indicate equality only if the
+ * arguments are identical, in the sense that they are at the same
+ * address.  If two distinct arcs, for example, connect the same pair
+ * of nodes (which is perfectly legal in the graph abstraction and can
+ * be used, for example, to represent multiple modes of travel between
+ * two nodes), those arcs are not the same.
+ */
+
+   class GraphComparator {
+   public:
+
+      bool operator()(NodeType *n1, NodeType *n2) {
+         return compare(n1, n2) < 0;
+      }
+
+      bool operator()(ArcType *a1, ArcType *a2) {
+         return compare(a1, a2) < 0;
+      }
+
+   };
+
+private:
+
+/* Instance variables */
+
+   Set<NodeType *> nodes;                 /* The set of nodes in the graph */
+   Set<ArcType *> arcs;                   /* The set of arcs in the graph  */
+   Map<std::string, NodeType *> nodeMap;  /* A map from names to nodes     */
+   GraphComparator comparator;            /* The comparator for this graph */
+
+/*
+ * Functions: operator=, copy constructor
+ * --------------------------------------
+ * These functions are part of the public interface of the class but are
+ * defined here to avoid adding confusion to the Graph class.
+ */
+
+public:
+
+   Graph & operator=(const Graph & src);
+   Graph(const Graph & src);
+
+   static int compare(NodeType *n1, NodeType *n2) {
+      if (n1 == n2) return 0;
+      if (n1->name < n2->name) return -1;
+      if (n1->name > n2->name) return +1;
+      return (n1 < n2) ? -1 : +1;
+   }
+
+   static int compare(ArcType *a1, ArcType *a2) {
+      if (a1 == a2) return 0;
+      NodeType *n1 = a1->start;
+      NodeType *n2 = a2->start;
+      if (n1 != n2) return compare(n1, n2);
+      n1 = a1->finish;
+      n2 = a2->finish;
+      if (n1 != n2) return compare(n1, n2);
+      return (a1 < a2) ? -1 : +1;
+   }
+
+private:
+
+   void deepCopy(const Graph & src);
+   NodeType *getExistingNode(std::string name) const;
+   NodeType *scanNode(TokenScanner & scanner);
+
+};
+
+extern void error(std::string msg);
+
+/*
+ * Implementation notes: Graph constructor
+ * ---------------------------------------
+ * Even though the body of the Graph constructor is empty, important
+ * work is done by the initializers, which ensure that the nodes and
+ * arcs set are given the correct comparison functions.
+ */
+
+template <typename NodeType,typename ArcType>
+Graph<NodeType,ArcType>::Graph() {
+   comparator = GraphComparator();
+   nodes = Set<NodeType *>(comparator);
+   arcs = Set<ArcType *>(comparator);
+}
+
+/*
+ * Implementation notes: Graph destructor
+ * --------------------------------------
+ * The destructor must free all heap storage used by this graph to
+ * represent the nodes and arcs.  The clear metho must also reclaim
+ * this memory, which means that the destructor can simply call
+ * clear to do the work.
+ */
+
+template <typename NodeType,typename ArcType>
+Graph<NodeType,ArcType>::~Graph() {
+   clear();
+}
+
+/*
+ * Implementation notes: size, isEmpty
+ * -----------------------------------
+ * These methods are defined in terms of the node set, so the implementation
+ * simply forwards the request there.  Note that it is impossible for a
+ * graph to have arcs if it has no nodes.
+ */
+
+template <typename NodeType,typename ArcType>
+int Graph<NodeType,ArcType>::size() const {
+   return nodes.size();
+}
+
+template <typename NodeType,typename ArcType>
+bool Graph<NodeType,ArcType>::isEmpty() const {
+   return nodes.isEmpty();
+}
+
+/*
+ * Implementation notes: clear
+ * ---------------------------
+ * The implementation of clear first frees the nodes and arcs in
+ * their respective sets and then uses the Set class clear method
+ * to ensure that these sets are empty.
+ */
+
+template <typename NodeType,typename ArcType>
+void Graph<NodeType,ArcType>::clear() {
+   foreach (NodeType *node in nodes) {
+      delete node;
+   }
+   foreach (ArcType *arc in arcs) {
+      delete arc;
+   }
+   arcs.clear();
+   nodes.clear();
+   nodeMap.clear();
+}
+
+/*
+ * Implementation notes: addNode
+ * -----------------------------
+ * The addNode method appears in two forms: one that creates a node
+ * from its name and one that assumes that the client has created
+ * the new node.  In each case, the implementation must add the node
+ * the set of nodes for the graph and add the name-to-node association
+ * to the node map.
+ */
+
+template <typename NodeType,typename ArcType>
+NodeType *Graph<NodeType,ArcType>::addNode(std::string name) {
+   NodeType *node = new NodeType();
+   node->arcs = Set<ArcType *>(comparator);
+   node->name = name;
+   return addNode(node);
+}
+
+template <typename NodeType,typename ArcType>
+NodeType *Graph<NodeType,ArcType>::addNode(NodeType *node) {
+   if (nodeMap.containsKey(node->name)) {
+      error("addNode: node " + node->name + " already exists");
+   }
+   nodes.add(node);
+   nodeMap[node->name] = node;
+   return node;
+}
+
+/*
+ * Implementation notes: removeNode
+ * --------------------------------
+ * The removeNode method must remove the specified node but must
+ * also remove any arcs in the graph containing the node.  To avoid
+ * changing the node set during iteration, this implementation creates
+ * a vector of arcs that require deletion.
+ */
+
+template <typename NodeType,typename ArcType>
+void Graph<NodeType,ArcType>::removeNode(std::string name) {
+   removeNode(getExistingNode(name));
+}
+
+template <typename NodeType,typename ArcType>
+void Graph<NodeType,ArcType>::removeNode(NodeType *node) {
+   Vector<ArcType *> toRemove;
+   foreach (ArcType *arc in arcs) {
+      if (arc->start == node || arc->finish == node) {
+         toRemove.add(arc);
+      }
+   }
+   foreach (ArcType *arc in toRemove) {
+      removeArc(arc);
+   }
+   nodes.remove(node);
+}
+
+/*
+ * Implementation notes: getNode, getExistingNode
+ * ----------------------------------------------
+ * The getNode method simply looks up the name in the map, which correctly
+ * returns NULL if the name is not found.  Other methods in the
+ * implementation call the private method getExistingNode instead,
+ * which checks for a NULL value and signals an error.
+ */
+
+template <typename NodeType,typename ArcType>
+NodeType *Graph<NodeType,ArcType>::getNode(std::string name) const {
+   return nodeMap.get(name);
+}
+
+template <typename NodeType,typename ArcType>
+NodeType *Graph<NodeType,ArcType>::getExistingNode(std::string name) const {
+   NodeType *node = nodeMap.get(name);
+   if (node == NULL) error("Graph class: No node named " + name);
+   return node;
+}
+
+/*
+ * Implementation notes: addArc
+ * ----------------------------
+ * The addArc method appears in three forms, as described in the
+ * interface.  The code for each form of the method, however, is
+ * quite straightforward.
+ */
+
+template <typename NodeType,typename ArcType>
+ArcType *Graph<NodeType,ArcType>::addArc(std::string s1, std::string s2) {
+   return addArc(getExistingNode(s1), getExistingNode(s2));
+}
+
+template <typename NodeType,typename ArcType>
+ArcType *Graph<NodeType,ArcType>::addArc(NodeType *n1, NodeType *n2) {
+   ArcType *arc = new ArcType();
+   arc->start = n1;
+   arc->finish = n2;
+   return addArc(arc);
+}
+
+template <typename NodeType,typename ArcType>
+ArcType *Graph<NodeType,ArcType>::addArc(ArcType *arc) {
+   arc->start->arcs.add(arc);
+   arcs.add(arc);
+   return arc;
+}
+
+/*
+ * Implementation notes: removeArc
+ * -------------------------------
+ * These methods remove arcs from the graph, which is ordinarily simply
+ * a matter of removing the arc from two sets: the set of arcs in the
+ * graph as a whole and the set of arcs in the starting node.  The
+ * methods that remove an arc specified by its endpoints, however,
+ * must take account of the fact that there might be more than one
+ * such arc and delete all of them.
+ */
+
+template <typename NodeType,typename ArcType>
+void Graph<NodeType,ArcType>::removeArc(std::string s1, std::string s2) {
+   removeArc(getExistingNode(s1), getExistingNode(s2));
+}
+
+template <typename NodeType,typename ArcType>
+void Graph<NodeType,ArcType>::removeArc(NodeType *n1, NodeType *n2) {
+   Vector<ArcType *> toRemove;
+   foreach (ArcType *arc in arcs) {
+      if (arc->start == n1 && arc->finish == n2) {
+         toRemove.add(arc);
+      }
+   }
+   foreach (ArcType *arc in toRemove) {
+      removeArc(arc);
+   }
+}
+
+template <typename NodeType,typename ArcType>
+void Graph<NodeType,ArcType>::removeArc(ArcType *arc) {
+   arc->start->arcs.remove(arc);
+   arcs.remove(arc);
+}
+
+/*
+ * Implementation notes: isConnected
+ * ---------------------------------
+ * Node n1 is connected to n2 if any of the arcs leaving n1 finish at n2.
+ * The two versions of this method allow nodes to be specified either as
+ * node pointers or by name.
+ */
+
+template <typename NodeType,typename ArcType>
+bool Graph<NodeType,ArcType>::isConnected(NodeType *n1, NodeType *n2) const {
+   foreach (ArcType *arc in n1->arcs) {
+      if (arc->finish == n2) return true;
+   }
+   return false;
+}
+
+template <typename NodeType,typename ArcType>
+bool Graph<NodeType,ArcType>::isConnected(std::string s1,
+                                          std::string s2) const {
+   return isConnected(getExistingNode(s1), getExistingNode(s2));
+}
+
+/*
+ * Implementation notes: getNodeSet, getArcSet
+ * -------------------------------------------
+ * These methods simply return the set requested by the client.  The
+ * sets are returned by reference for efficiency, because doing so
+ * eliminates the need to copy the set.
+ */
+
+template <typename NodeType,typename ArcType>
+const Set<NodeType *> & Graph<NodeType,ArcType>::getNodeSet() const {
+   return nodes;
+}
+
+template <typename NodeType,typename ArcType>
+const Set<ArcType *> & Graph<NodeType,ArcType>::getArcSet() const {
+   return arcs;
+}
+
+template <typename NodeType,typename ArcType>
+const Set<ArcType *> &
+      Graph<NodeType,ArcType>::getArcSet(NodeType *node) const {
+   return node->arcs;
+}
+
+template <typename NodeType,typename ArcType>
+const Set<ArcType *> &
+      Graph<NodeType,ArcType>::getArcSet(std::string name) const {
+   return getArcSet(getExistingNode(name));
+}
+
+/*
+ * Implementation notes: getNeighbors
+ * ----------------------------------
+ * This implementation recomputes the set each time, which is reasonably
+ * efficient if the degree of the node is small.
+ */
+
+template <typename NodeType,typename ArcType>
+const Set<NodeType *>
+          Graph<NodeType,ArcType>::getNeighbors(NodeType *node) const {
+   Set<NodeType *> nodes = Set<NodeType *>(comparator);
+   foreach (ArcType *arc in node->arcs) {
+      nodes.add(arc->finish);
+   }
+   return nodes;
+}
+
+template <typename NodeType,typename ArcType>
+const Set<NodeType *>
+          Graph<NodeType,ArcType>::getNeighbors(std::string name) const {
+   return getNeighbors(getExistingNode(name));
+}
+
+/*
+ * Implementation notes: operator=, copy constructor
+ * -------------------------------------------------
+ * These methods ensure that copying a graph creates an entirely new
+ * parallel structure of nodes and arcs.
+ */
+
+template <typename NodeType,typename ArcType>
+Graph<NodeType,ArcType>
+           & Graph<NodeType,ArcType>::operator=(const Graph & src) {
+   if (this != &src) {
+      clear();
+      deepCopy(src);
+   }
+   return *this;
+}
+
+template <typename NodeType,typename ArcType>
+Graph<NodeType,ArcType>::Graph(const Graph & src) {
+   nodes = Set<NodeType *>(comparator);
+   arcs = Set<ArcType *>(comparator);
+   deepCopy(src);
+}
+
+/*
+ * Private method: deepCopy
+ * ------------------------
+ * Common code factored out of the copy constructor and operator= to
+ * copy the contents from the other graph.
+ */
+
+template <typename NodeType,typename ArcType>
+void Graph<NodeType,ArcType>::deepCopy(const Graph & src) {
+   foreach (NodeType *oldNode in src.nodes) {
+      NodeType *newNode = new NodeType();
+      *newNode = *oldNode;
+      newNode->arcs.clear();
+      addNode(newNode);
+   }
+   foreach (ArcType *oldArc in src.arcs) {
+      ArcType *newArc = new ArcType();
+      *newArc = *oldArc;
+      newArc->start = getExistingNode(oldArc->start->name);
+      newArc->finish = getExistingNode(oldArc->finish->name);
+      addArc(newArc);
+   }
+}
+
+template <typename NodeType,typename ArcType>
+std::string Graph<NodeType,ArcType>::toString() {
+   ostringstream os;
+   os << *this;
+   return os.str();
+}
+
+/*
+ * Implementation notes: scanGraphEntry
+ * ------------------------------------
+ * The scanGraphEntry and its helper methods take a scanner that is
+ * initialized to the input stream and has the options ignoreWhitespace,
+ * scanStrings, and scanNumbers set.
+ */
+
+template <typename NodeType,typename ArcType>
+bool Graph<NodeType,ArcType>::scanGraphEntry(TokenScanner & scanner) {
+   NodeType *n1 = scanNode(scanner);
+   if (n1 == NULL) return false;
+   std::string op = scanner.nextToken();
+   if (op != "-" && op != "->") {
+      scanner.saveToken(op);
+      return true;
+   }
+   NodeType *n2 = scanNode(scanner);
+   if (n2 == NULL) error("scanGraphEntry: Missing node after " + op);
+   ArcType *forward = new ArcType();
+   forward->start = n1;
+   forward->finish = n2;
+   addArc(forward);
+   ArcType *backward = NULL;
+   if (op == "-") {
+      backward = new ArcType();
+      backward->start = n2;
+      backward->finish = n1;
+      addArc(backward);
+   }
+   scanArcData(scanner, forward, backward);
+   return true;
+}
+
+template <typename NodeType,typename ArcType>
+NodeType *Graph<NodeType,ArcType>::scanNode(TokenScanner & scanner) {
+   std::string token = scanner.nextToken();
+   switch (scanner.getTokenType(token)) {
+    case WORD: break;
+    case STRING: token = scanner.getStringValue(token); break;
+    default: scanner.saveToken(token); return NULL;
+   }
+   NodeType *node = getNode(token);
+   if (node == NULL) {
+      node = new NodeType();
+      node->name = token;
+      scanNodeData(scanner, node);
+      addNode(node);
+   }
+   return node;
+}
+
+/*
+ * Implementation notes: << and >>
+ * -------------------------------
+ * The insertion and extraction operators for graphs are more complicated
+ * than for the standard collection types because the nodes and arcs can
+ * contain client-specific data.  To ensure that this information is
+ * correctly written and read by these operators, clients must override
+ * the methods writeNodeData, writeArcData, scanNodeData, and scanArcData.
+ */
+
+template <typename NodeType,typename ArcType>
+std::ostream & operator<<(std::ostream & os,
+                          const Graph<NodeType,ArcType> & g) {
+   os << "{";
+   bool started = false;
+   foreach (NodeType *node in g.getNodeSet()) {
+      if (started) os << ", ";
+      writeGenericValue(os, node->name, false);
+      g.writeNodeData(os, node);
+      started = true;
+   }
+   foreach (ArcType *arc in g.getArcSet()) {
+      os << ", ";
+      writeGenericValue(os, arc->start->name, false);
+      os << " -> ";
+      writeGenericValue(os, arc->finish->name, false);
+      g.writeArcData(os, arc);
+   }
+   return os << "}";
+}
+
+template <typename NodeType,typename ArcType>
+std::istream & operator>>(std::istream & is, Graph<NodeType,ArcType> & g) {
+   TokenScanner scanner(is);
+   scanner.ignoreWhitespace();
+   scanner.scanNumbers();
+   scanner.scanStrings();
+   scanner.addOperator("->");
+   std::string token = scanner.nextToken();
+   if (token != "{") error("operator >>: Missing {");
+   g.clear();
+   while (g.scanGraphEntry(scanner)) {
+      token = scanner.nextToken();
+      if (token == "}") {
+         scanner.saveToken(token);
+      } else if (token != ",") {
+         error("operator >>: Unexpected token " + token);
+      }
+   }
+   token = scanner.nextToken();
+   if (token != "}") error("operator >>: Missing }");
+   return is;
+}
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/grid.h b/labb8/lib/StanfordCPPLib/grid.h
new file mode 100755
index 0000000..0a23b46
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/grid.h
@@ -0,0 +1,516 @@
+/*
+ * File: grid.h
+ * ------------
+ * This file exports the <code>Grid</code> class, which offers a
+ * convenient abstraction for representing a two-dimensional array.
+ */
+
+#ifndef _grid_h
+#define _grid_h
+
+#include "foreach.h"
+#include "strlib.h"
+#include "vector.h"
+
+/*
+ * Class: Grid<ValueType>
+ * ----------------------
+ * This class stores an indexed, two-dimensional array.  The following code,
+ * for example, creates an identity matrix of size <code>n</code>, in which
+ * the elements are 1.0 along the main diagonal and 0.0 everywhere else:
+ *
+ *<pre>
+ *    Grid&lt;double&gt; createIdentityMatrix(int n) {
+ *       Grid&lt;double&gt; matrix(n, n);
+ *       for (int i = 0; i &lt; n; i++) {
+ *          matrix[i][i] = 1.0;
+ *       }
+ *       return matrix;
+ *    }
+ *</pre>
+ */
+
+template <typename ValueType>
+class Grid {
+
+public:
+
+/* Forward reference */
+   class GridRow;
+
+/*
+ * Constructor: Grid
+ * Usage: Grid<ValueType> grid;
+ *        Grid<ValueType> grid(nRows, nCols);
+ * ------------------------------------------
+ * Initializes a new grid.  The second form of the constructor is
+ * more common and creates a grid with the specified number of rows
+ * and columns.  Each element of the grid is initialized to the
+ * default value for the type.  The default constructor creates an
+ * empty grid for which the client must call <code>resize</code> to
+ * set the dimensions.
+ */
+
+   Grid();
+   Grid(int nRows, int nCols);
+
+/*
+ * Destructor: ~Grid
+ * -----------------
+ * Frees any heap storage associated with this grid.
+ */
+
+   virtual ~Grid();
+
+/*
+ * Method: numRows
+ * Usage: int nRows = grid.numRows();
+ * ----------------------------------
+ * Returns the number of rows in the grid.
+ */
+
+   int numRows() const;
+
+/*
+ * Method: numCols
+ * Usage: int nCols = grid.numCols();
+ * ----------------------------------
+ * Returns the number of columns in the grid.
+ */
+
+   int numCols() const;
+
+/*
+ * Method: resize
+ * Usage: grid.resize(nRows, nCols);
+ * ---------------------------------
+ * Reinitializes the grid to have the specified number of rows
+ * and columns.  Any previous grid contents are discarded.
+ */
+
+   void resize(int nRows, int nCols);
+
+/*
+ * Method: inBounds
+ * Usage: if (grid.inBounds(row, col)) ...
+ * ---------------------------------------
+ * Returns <code>true</code> if the specified row and column position
+ * is inside the bounds of the grid.
+ */
+
+   bool inBounds(int row, int col) const;
+
+/*
+ * Method: get
+ * Usage: ValueType value = grid.get(row, col);
+ * --------------------------------------------
+ * Returns the element at the specified <code>row</code>/<code>col</code>
+ * position in this grid.  This method signals an error if the
+ * <code>row</code> and <code>col</code> arguments are outside
+ * the grid boundaries.
+ */
+
+   ValueType get(int row, int col);
+   const ValueType & get(int row, int col) const;
+
+/*
+ * Method: set
+ * Usage: grid.set(row, col, value);
+ * ---------------------------------
+ * Replaces the element at the specified <code>row</code>/<code>col</code>
+ * location in this grid with a new value.  This method signals an error
+ * if the <code>row</code> and <code>col</code> arguments are outside
+ * the grid boundaries.
+ */
+
+   void set(int row, int col, ValueType value);
+
+/*
+ * Operator: []
+ * Usage:  grid[row][col]
+ * ----------------------
+ * Overloads <code>[]</code> to select elements from this grid.
+ * This extension enables the use of traditional array notation to
+ * get or set individual elements.  This method signals an error if
+ * the <code>row</code> and <code>col</code> arguments are outside
+ * the grid boundaries.
+ */
+
+   GridRow operator[](int row);
+   const GridRow operator[](int row) const;
+
+/*
+ * Method: toString
+ * Usage: string str = grid.toString();
+ * ------------------------------------
+ * Converts the grid to a printable string representation.
+ */
+
+   std::string toString();
+
+/*
+ * Method: mapAll
+ * Usage: grid.mapAll(fn);
+ * -----------------------
+ * Calls the specified function on each element of the grid.  The
+ * elements are processed in <b><i>row-major order,</i></b> in which
+ * all the elements of row 0 are processed, followed by the elements
+ * in row 1, and so on.
+ */
+
+   void mapAll(void (*fn)(ValueType value)) const;
+   void mapAll(void (*fn)(const ValueType & value)) const;
+
+   template <typename FunctorType>
+   void mapAll(FunctorType fn) const;
+
+/*
+ * Additional Grid operations
+ * --------------------------
+ * In addition to the methods listed in this interface, the Grid
+ * class supports the following operations:
+ *
+ *   - Stream I/O using the << and >> operators
+ *   - Deep copying for the copy constructor and assignment operator
+ *   - Iteration using the range-based for statement and STL iterators
+ *
+ * The iteration forms process the grid in row-major order.
+ */
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in the file is logically part    */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+/*
+ * Implementation notes: Grid data structure
+ * -----------------------------------------
+ * The Grid is internally managed as a dynamic array of elements.
+ * The array itself is one-dimensional, the logical separation into
+ * rows and columns is done by arithmetic computation.  The layout
+ * is in row-major order, which is to say that the entire first row
+ * is laid out contiguously, followed by the entire second row,
+ * and so on.
+ */
+
+/* Instance variables */
+
+   ValueType *elements;  /* A dynamic array of the elements   */
+   int nRows;            /* The number of rows in the grid    */
+   int nCols;            /* The number of columns in the grid */
+
+/* Private method prototypes */
+
+   void checkRange(int row, int col);
+
+/*
+ * Hidden features
+ * ---------------
+ * The remainder of this file consists of the code required to
+ * support deep copying and iteration.  Including these methods
+ * in the public interface would make that interface more
+ * difficult to understand for the average client.
+ */
+
+/*
+ * Deep copying support
+ * --------------------
+ * This copy constructor and operator= are defined to make a
+ * deep copy, making it possible to pass/return grids by value
+ * and assign from one grid to another.  The entire contents of
+ * the grid, including all elements, are copied.  Each grid
+ * element is copied from the original grid to the copy using
+ * assignment (operator=).  Making copies is generally avoided
+ * because of the expense and thus, grids are typically passed
+ * by reference, however, when a copy is needed, these operations
+ * are supported.
+ */
+
+   void deepCopy(const Grid & grid) {
+      int n = grid.nRows * grid.nCols;
+      elements = new ValueType[n];
+      for (int i = 0; i < n; i++) {
+         elements[i] = grid.elements[i];
+      }
+      nRows = grid.nRows;
+      nCols = grid.nCols;
+   }
+
+public:
+
+   Grid & operator=(const Grid & src) {
+      if (this != &src) {
+         delete[] elements;
+         deepCopy(src);
+      }
+      return *this;
+   }
+
+   Grid(const Grid & src) {
+      deepCopy(src);
+   }
+
+/*
+ * Iterator support
+ * ----------------
+ * The classes in the StanfordCPPLib collection implement input
+ * iterators so that they work symmetrically with respect to the
+ * corresponding STL classes.
+ */
+
+   class iterator : public std::iterator<std::input_iterator_tag, ValueType> {
+
+   public:
+
+      iterator(const Grid *gp, int index) {
+         this->gp = gp;
+         this->index = index;
+      }
+
+      iterator(const iterator & it) {
+         this->gp = it.gp;
+         this->index = it.index;
+      }
+
+      iterator & operator++() {
+         index++;
+         return *this;
+      }
+
+      iterator operator++(int) {
+         iterator copy(*this);
+         operator++();
+         return copy;
+      }
+
+      bool operator==(const iterator & rhs) {
+         return gp == rhs.gp && index == rhs.index;
+      }
+
+      bool operator!=(const iterator & rhs) {
+         return !(*this == rhs);
+      }
+
+      ValueType & operator*() {
+         return gp->elements[index];
+      }
+
+      ValueType *operator->() {
+         return &gp->elements[index];
+      }
+
+   private:
+      const Grid *gp;
+      int index;
+   };
+
+   iterator begin() const {
+      return iterator(this, 0);
+   }
+
+   iterator end() const {
+      return iterator(this, nRows * nCols);
+   }
+
+/*
+ * Private class: Grid<ValType>::GridRow
+ * -------------------------------------
+ * This section of the code defines a nested class within the Grid template
+ * that makes it possible to use traditional subscripting on Grid values.
+ */
+
+   class GridRow {
+   public:
+      GridRow() {
+         /* Empty */
+      }
+
+      ValueType & operator[](int col) {
+         extern void error(std::string msg);
+         if (!gp->inBounds(row, col)) {
+            error("Grid index values out of range");
+         }
+         return gp->elements[(row * gp->nCols) + col];
+      }
+
+      ValueType operator[](int col) const {
+         extern void error(std::string msg);
+         if (!gp->inBounds(row, col)) {
+            error("Grid index values out of range");
+         }
+         return gp->elements[(row * gp->nCols) + col];
+      }
+
+   private:
+      GridRow(Grid *gridRef, int index) {
+         gp = gridRef;
+         row = index;
+      }
+
+      Grid *gp;
+      int row;
+      friend class Grid;
+   };
+   friend class GridRow;
+
+};
+
+extern void error(std::string msg);
+
+template <typename ValueType>
+Grid<ValueType>::Grid() {
+   elements = NULL;
+   nRows = 0;
+   nCols = 0;
+}
+
+template <typename ValueType>
+Grid<ValueType>::Grid(int nRows, int nCols) {
+   elements = NULL;
+   resize(nRows, nCols);
+}
+
+template <typename ValueType>
+Grid<ValueType>::~Grid() {
+   if (elements != NULL) delete[] elements;
+}
+
+template <typename ValueType>
+int Grid<ValueType>::numRows() const {
+   return nRows;
+}
+
+template <typename ValueType>
+int Grid<ValueType>::numCols() const {
+   return nCols;
+}
+
+template <typename ValueType>
+void Grid<ValueType>::resize(int nRows, int nCols) {
+   if (nRows < 0 || nCols < 0) {
+      error("Attempt to resize grid to invalid size ("
+            + integerToString(nRows) + ", "
+            + integerToString(nCols) + ")");
+   }
+   if (elements != NULL) delete[] elements;
+   this->nRows = nRows;
+   this->nCols = nCols;
+   elements = new ValueType[nRows * nCols];
+   ValueType value = ValueType();
+   for (int i = 0; i < nRows * nCols; i++) {
+      elements[i] = value;
+   }
+}
+
+template <typename ValueType>
+bool Grid<ValueType>::inBounds(int row, int col) const {
+   return row >= 0 && col >= 0 && row < nRows && col < nCols;
+}
+
+template <typename ValueType>
+ValueType Grid<ValueType>::get(int row, int col) {
+   if (!inBounds(row, col)) error("get: Grid indices out of bounds");
+   return elements[(row * nCols) + col];
+}
+
+template <typename ValueType>
+const ValueType & Grid<ValueType>::get(int row, int col) const {
+   if (!inBounds(row, col)) error("get: Grid indices out of bounds");
+   return elements[(row * nCols) + col];
+}
+
+template <typename ValueType>
+void Grid<ValueType>::set(int row, int col, ValueType value) {
+   if (!inBounds(row, col)) error("set: Grid indices out of bounds");
+   elements[(row * nCols) + col] = value;
+}
+
+template <typename ValueType>
+typename Grid<ValueType>::GridRow Grid<ValueType>::operator[](int row) {
+   return GridRow(this, row);
+}
+
+template <typename ValueType>
+const typename Grid<ValueType>::GridRow
+               Grid<ValueType>::operator[](int row) const {
+   return GridRow(this, row);
+}
+
+template <typename ValueType>
+void Grid<ValueType>::mapAll(void (*fn)(ValueType value)) const {
+   for (int i = 0; i < nRows; i++) {
+      for (int j = 0; j < nCols; j++) {
+         fn(get(i, j));
+      }
+   }
+}
+
+template <typename ValueType>
+void Grid<ValueType>::mapAll(void (*fn)(const ValueType & value)) const {
+   for (int i = 0; i < nRows; i++) {
+      for (int j = 0; j < nCols; j++) {
+         fn(get(i, j));
+      }
+   }
+}
+
+template <typename ValueType>
+template <typename FunctorType>
+void Grid<ValueType>::mapAll(FunctorType fn) const {
+   for (int i = 0; i < nRows; i++) {
+      for (int j = 0; j < nCols; j++) {
+         fn(get(i, j));
+      }
+   }
+}
+
+template <typename ValueType>
+std::string Grid<ValueType>::toString() {
+   ostringstream os;
+   os << *this;
+   return os.str();
+}
+
+/*
+ * Implementation notes: << and >>
+ * -------------------------------
+ * The insertion and extraction operators use the template facilities in
+ * strlib.h to read and write generic values in a way that treats strings
+ * specially.
+ */
+
+template <typename ValueType>
+std::ostream & operator<<(std::ostream & os, const Grid<ValueType> & grid) {
+   os << "{";
+   int nRows = grid.numRows();
+   int nCols = grid.numCols();
+   for (int i = 0; i < nRows; i++) {
+      if (i > 0) os << ", ";
+      os << "{";
+      for (int j = 0; j < nCols; j++) {
+         if (j > 0) os << ", ";
+         writeGenericValue(os, grid.get(i, j), true);
+      }
+      os << "}";
+   }
+   return os << "}";
+}
+
+template <typename ValueType>
+std::istream & operator>>(std::istream & is, Grid<ValueType> & grid) {
+   Vector< Vector<ValueType> > vec2d;
+   is >> vec2d;
+   int nRows = vec2d.size();
+   int nCols = (nRows == 0) ? 0 : vec2d[0].size();
+   grid.resize(nRows, nCols);
+   for (int i = 0; i < nRows; i++) {
+      for (int j = 0; j < nCols; j++) {
+         grid[i][j] = vec2d[i][j];
+      }
+   }
+   return is;
+}
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/gtimer.cpp b/labb8/lib/StanfordCPPLib/gtimer.cpp
new file mode 100755
index 0000000..20e160d
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/gtimer.cpp
@@ -0,0 +1,62 @@
+/*
+ * File: gtimer.cpp
+ * ----------------
+ * This file implements the gtimer.h interface.
+ */
+
+#include <iostream>
+#include <sstream>
+#include <string>
+#include "platform.h"
+using namespace std;
+
+/* Global variables */
+
+static Platform *pp = getPlatform();
+
+/* Implementation of the GTimer class */
+
+GTimer::GTimer(double milliseconds) {
+   gtd = new GTimerData();
+   gtd->refCount = 1;
+   pp->createTimer(*this, milliseconds);
+}
+
+GTimer::~GTimer() {
+   if (--gtd->refCount == 0) delete gtd;
+}
+
+void GTimer::start() {
+   pp->startTimer(*this);
+}
+
+void GTimer::stop() {
+   pp->stopTimer(*this);
+}
+
+bool GTimer::operator==(GTimer t2) {
+   return gtd == t2.gtd;
+}
+
+bool GTimer::operator!=(GTimer t2) {
+   return gtd != t2.gtd;
+}
+
+GTimer::GTimer(GTimerData *gtd) {
+   this->gtd = gtd;
+   gtd->refCount++;
+}
+
+GTimer::GTimer(const GTimer & src) {
+   this->gtd = src.gtd;
+   this->gtd->refCount++;
+}
+
+GTimer & GTimer::operator=(const GTimer & src) {
+   if (this != &src) {
+      if (--gtd->refCount == 0) delete gtd;
+      this->gtd = src.gtd;
+      this->gtd->refCount++;
+   }
+   return *this;
+}
diff --git a/labb8/lib/StanfordCPPLib/gtimer.h b/labb8/lib/StanfordCPPLib/gtimer.h
new file mode 100755
index 0000000..a0a6d7d
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/gtimer.h
@@ -0,0 +1,116 @@
+/*
+ * File: gtimer.h
+ * --------------
+ * This file defines the <code>GTimer</code> class, which implements a
+ * general interval timer.
+ */
+
+#ifndef _gtimer_h
+#define _gtimer_h
+
+#include <string>
+
+/*
+ * Friend type: GTimerData
+ * -----------------------
+ * This type maintains a reference count to determine when it is
+ * possible to free the timer.  The address of this block is used
+ * as the timer id.
+ */
+
+struct GTimerData {
+   int refCount;
+};
+
+/*
+ * Class: GTimer
+ * -------------
+ * This class implements a simple interval timer that generates a
+ * <code>GTimerEvent</code> with a specified frequency.  Copying
+ * a <code>GTimer</code> object is legal and creates an object that
+ * refers to the same internal timer.
+ */
+
+class GTimer {
+
+public:
+
+/*
+ * Constructor: GTimer
+ * Usage: GTimer timer(milliseconds);
+ * ----------------------------------
+ * Creates a timer object that generates a <code>GTimerEvent</code>
+ * each time the specified number of milliseconds has elapsed.  No
+ * events are generated until the client calls <code>start</code>
+ * on the timer.  For more details on using timers, see the documentation
+ * for the <a href="GTimerEvent-class.html"><code>GTimerEvent</code></a>
+ * class.
+ */
+
+   GTimer(double milliseconds);
+
+/*
+ * Destructor: ~GTimer
+ * -------------------
+ * Frees the resources associated with the timer.
+ */
+
+   virtual ~GTimer();
+
+/*
+ * Method: start
+ * Usage: timer.start();
+ * ---------------------
+ * Starts the timer.  A timer continues to generate timer events until it
+ * is stopped; to achieve the effect of a one-shot timer, the simplest
+ * approach is to call the <code>stop</code> method inside the event
+ * handler.
+ */
+
+   void start();
+
+/*
+ * Method: stop
+ * Usage: timer.stop();
+ * --------------------
+ * Stops the timer so that it stops generating events until it is restarted.
+ */
+
+   void stop();
+
+/*
+ * Friend operator: ==
+ * Usage: if (t1 == t2) ...
+ * ------------------------
+ * Checks whether the two objects refer to the same timer.
+ */
+
+   bool operator==(GTimer t2);
+
+/*
+ * Friend operator: !=
+ * Usage: if (t1 != t2) ...
+ * ------------------------
+ * Checks whether the two objects refer to the different timers.
+ */
+
+   bool operator!=(GTimer t2);
+
+/* Private section */
+
+   GTimer(GTimerData *gtd);
+   GTimer(const GTimer & src);
+   GTimer & operator=(const GTimer & src);
+
+private:
+
+/* Instance variables */
+
+   GTimerData *gtd;
+
+   friend class Platform;
+   friend class GTimerEvent;
+
+};
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/gtypes.cpp b/labb8/lib/StanfordCPPLib/gtypes.cpp
new file mode 100755
index 0000000..2e5c678
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/gtypes.cpp
@@ -0,0 +1,196 @@
+/*
+ * File: gtypes.cpp
+ * ----------------
+ * This file implements the classes in the gtypes.h interface.
+ */
+
+#include <string>
+#include <cmath>
+#include "error.h"
+#include "gtypes.h"
+#include "strlib.h"
+using namespace std;
+
+static const double PI = 3.14159265358979;
+static const int HASH_MASK = int(unsigned(-1) >> 1);
+
+/*
+ * Implementation notes: GPoint class
+ * ----------------------------------
+ * The GPoint class itself is entirely straightforward.  The relational
+ * operators compare the x components first, followed by the y component.
+ * The hashCode function computes the exclusive-or of the individual words.
+ */
+
+GPoint::GPoint() {
+   x = 0;
+   y = 0;
+}
+
+GPoint::GPoint(double x, double y) {
+   this->x = x;
+   this->y = y;
+}
+
+double GPoint::getX() const {
+   return x;
+}
+
+double GPoint::getY() const {
+   return y;
+}
+
+string GPoint::toString() const {
+   return "(" + realToString(x) + ", " + realToString(y) + ")";
+}
+
+ostream & operator<<(ostream & os, const GPoint & pt) {
+   return os << pt.toString();
+}
+
+bool operator==(const GPoint & p1, const GPoint & p2) {
+   return p1.x == p2.x && p1.y == p2.y;
+}
+
+bool operator!=(const GPoint & p1, const GPoint & p2) {
+   return !(p1 == p2);
+}
+
+int hashCode(const GPoint & pt) {
+   int hash = 0;
+   for (size_t i = 0; i < sizeof(double) / sizeof(int); i++) {
+      hash ^= ((int *) &pt.x)[i] ^ ((int *) &pt.y)[i];
+   }
+   return HASH_MASK & hash;
+}
+
+/*
+ * Implementation notes: GDimension class
+ * --------------------------------------
+ * The GDimension class itself is entirely straightforward.  The
+ * relational operators compare the width first, followed by the height.
+ * The hashCode function computes the exclusive-or of the individual words.
+ */
+
+GDimension::GDimension() {
+   width = 0;
+   height = 0;
+}
+
+GDimension::GDimension(double width, double height) {
+   this->width = width;
+   this->height = height;
+}
+
+double GDimension::getWidth() const {
+   return width;
+}
+
+double GDimension::getHeight() const {
+   return height;
+}
+
+string GDimension::toString() const {
+   return "(" + realToString(width) + ", " + realToString(height) + ")";
+}
+
+ostream & operator<<(ostream & os, const GDimension & dim) {
+   return os << dim.toString();
+}
+
+bool operator==(const GDimension & d1, const GDimension & d2) {
+   return d1.width == d2.width && d1.height == d2.height;
+}
+
+bool operator!=(const GDimension & d1, const GDimension & d2) {
+   return !(d1 == d2);
+}
+
+int hashCode(const GDimension & dim) {
+   int hash = 0;
+   for (size_t i = 0; i < sizeof(double) / sizeof(int); i++) {
+      hash ^= ((int *) &dim.width)[i] ^ ((int *) &dim.height)[i];
+   }
+   return HASH_MASK & hash;
+}
+
+/*
+ * Implementation notes: GRectangle class
+ * --------------------------------------
+ * The GRectangle class itself is entirely straightforward.  The
+ * relational operators compare the components in the following order:
+ * x, y, width, height.  The hashCode function computes the exclusive-or
+ * of the individual words.
+ */
+
+GRectangle::GRectangle() {
+   x = 0;
+   y = 0;
+   width = 0;
+   height = 0;
+}
+
+GRectangle::GRectangle(double x, double y, double width, double height) {
+   this->x = x;
+   this->y = y;
+   this->width = width;
+   this->height = height;
+}
+
+double GRectangle::getX() const {
+   return x;
+}
+
+double GRectangle::getY() const {
+   return y;
+}
+
+double GRectangle::getWidth() const {
+   return width;
+}
+
+double GRectangle::getHeight() const {
+   return height;
+}
+
+bool GRectangle::isEmpty() const {
+   return width <= 0 || height <= 0;
+}
+
+bool GRectangle::contains(double x, double y) const {
+   return x >= this->x && y >= this->y
+                       && x < this->x + width
+                       && y < this->y + height;
+}
+
+bool GRectangle::contains(GPoint pt) const {
+   return contains(pt.getX(), pt.getY());
+}
+
+string GRectangle::toString() const {
+   return "(" + realToString(x) + ", " + realToString(y) + ", "
+              + realToString(width) + ", " + realToString(height) + ")";
+}
+
+ostream & operator<<(ostream & os, const GRectangle & rect) {
+   return os << rect.toString();
+}
+
+bool operator==(const GRectangle & r1, const GRectangle & r2) {
+   return r1.x == r2.x && r1.y == r2.y
+                       && r1.width == r2.width
+                       && r1.height == r2.height;
+}
+
+bool operator!=(const GRectangle & r1, const GRectangle & r2) {
+   return !(r1 == r2);
+}
+
+int hashCode(const GRectangle & r) {
+   int hash = 0;
+   for (size_t i = 0; i < sizeof(double) / sizeof(int); i++) {
+      hash ^= ((int *) &r.x)[i] ^ ((int *) &r.y)[i];
+      hash ^= ((int *) &r.width)[i] ^ ((int *) &r.height)[i];
+   }
+   return HASH_MASK & hash;
+}
diff --git a/labb8/lib/StanfordCPPLib/gtypes.h b/labb8/lib/StanfordCPPLib/gtypes.h
new file mode 100755
index 0000000..cd55b53
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/gtypes.h
@@ -0,0 +1,301 @@
+/*
+ * File: gtypes.h
+ * --------------
+ * This file defines classes for representing points, dimensions, and
+ * rectangles.
+ */
+
+#ifndef _gtypes_h
+#define _gtypes_h
+
+#include <iostream>
+#include <string>
+
+/*
+ * Class: GPoint
+ * -------------
+ * This class contains real-valued x and y fields.  It is used to
+ * represent a location on the graphics plane.
+ */
+
+class GPoint {
+
+public:
+
+/*
+ * Constructor: GPoint
+ * Usage: GPoint origin;
+ *        GPoint pt(x, y);
+ * -----------------------
+ * Creates a <code>GPoint</code> object with the specified <code>x</code>
+ * and <code>y</code> coordinates.  If the coordinates are not supplied,
+ * the default constructor sets these fields to 0.
+ */
+
+   GPoint();
+   GPoint(double x, double y);
+
+/*
+ * Method: getX
+ * Usage: double x = pt.getX();
+ * ----------------------------
+ * Returns the x component of the point.
+ */
+
+   double getX() const;
+
+/*
+ * Method: getY
+ * Usage: double y = pt.getY();
+ * ----------------------------
+ * Returns the y component of the point.
+ */
+
+   double getY() const;
+
+/*
+ * Method: toString
+ * Usage: string str = pt.toString();
+ * ----------------------------------
+ * Converts the <code>GPoint</code> to a string in the form
+ * <code>"(</code><i>x</i><code>,</code>&nbsp;<i>y</i><code>)"</code>.
+ */
+
+   std::string toString() const;
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in this class is logically part  */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+private:
+
+/* Instance variables */
+
+   double x;                       /* The x-coordinate of the point */
+   double y;                       /* The y-coordinate of the point */
+
+/* Friend declarations */
+
+   friend bool operator==(const GPoint & p1, const GPoint & p2);
+   friend bool operator!=(const GPoint & p1, const GPoint & p2);
+   friend int hashCode(const GPoint & pt);
+
+};
+
+/*
+ * Class: GDimension
+ * -----------------
+ * This class contains real-valued width and height fields.  It is used
+ * to indicate the size of a graphical object.
+ */
+
+class GDimension {
+
+public:
+
+/*
+ * Constructor: GDimension
+ * Usage: GDimension empty;
+ *        GDimension dim(width, height);
+ * -------------------------------------
+ * Creates a <code>GDimension</code> object with the specified
+ * <code>width</code> and <code>height</code> coordinates.  If the
+ * coordinates are not supplied, the default constructor sets these
+ * fields to 0.
+ */
+
+   GDimension();
+   GDimension(double width, double height);
+
+/*
+ * Method: getWidth
+ * Usage: double width = dim.getWidth();
+ * -------------------------------------
+ * Returns the width component of the <code>GDimension</code> object.
+ */
+
+   double getWidth() const;
+
+/*
+ * Method: getHeight
+ * Usage: double height = dim.getHeight();
+ * ---------------------------------------
+ * Returns the height component of the <code>GDimension</code> object.
+ */
+
+   double getHeight() const;
+
+/*
+ * Method: toString
+ * Usage: string str = dim.toString();
+ * -----------------------------------
+ * Converts the <code>GDimension</code> to a string in the form
+ * <code>"(</code><i>width</i><code>,</code>&nbsp;<i>height</i><code>)"</code>.
+ */
+
+   std::string toString() const;
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in this class is logically part  */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+private:
+
+/* Instance variables */
+
+   double width;                   /* The width of the GDimension       */
+   double height;                  /* The height of the GDimension      */
+
+/* Friend declarations */
+
+   friend bool operator==(const GDimension & d1, const GDimension & d2);
+   friend bool operator!=(const GDimension & d1, const GDimension & d2);
+   friend int hashCode(const GDimension & dim);
+
+};
+
+/*
+ * Class: GRectangle
+ * -----------------
+ * This type contains real-valued x, y, width, and height fields.  It is
+ * used to represent the bounding box of a graphical object.
+ */
+
+class GRectangle {
+
+public:
+
+/*
+ * Constructor: GRectangle
+ * Usage: GRectangle empty;
+ *        GRectangle r(x, y, width, height);
+ * -----------------------------------------
+ * Creates a <code>GRectangle</code> object with the specified components.
+ * If these parameters are not supplied, the default constructor sets
+ * these fields to 0.
+ */
+
+   GRectangle();
+   GRectangle(double x, double y, double width, double height);
+
+/*
+ * Method: getX
+ * Usage: double x = r.getX();
+ * ---------------------------
+ * Returns the x component of the rectangle.
+ */
+
+   double getX() const;
+
+/*
+ * Method: getY
+ * Usage: double y = pt.getY();
+ * ----------------------------
+ * Returns the y component of the rectangle.
+ */
+
+   double getY() const;
+
+/*
+ * Method: getWidth
+ * Usage: double width = r.getWidth();
+ * -----------------------------------
+ * Returns the width component of the rectangle.
+ */
+
+   double getWidth() const;
+
+/*
+ * Method: getHeight
+ * Usage: double height = pt.getHeight();
+ * --------------------------------------
+ * Returns the height component of the rectangle.
+ */
+
+   double getHeight() const;
+
+/*
+ * Method: isEmpty
+ * Usage: if (r.isEmpty()) ...
+ * ---------------------------
+ * Returns <code>true</code> if the rectangle is empty.
+ */
+
+   bool isEmpty() const;
+
+/*
+ * Method: contains
+ * Usage: if (r.contains(pt)) ...
+ *        if (r.contains(x, y)) ...
+ * --------------------------------
+ * Returns <code>true</code> if the rectangle contains the given point,
+ * which may be specified either as a point or as distinct coordinates.
+ */
+
+   bool contains(GPoint pt) const;
+   bool contains(double x, double y) const;
+
+/*
+ * Method: toString
+ * Usage: string str = r.toString();
+ * ---------------------------------
+ * Converts the <code>GRectangle</code> to a string in the form
+ * <code>"(</code><i>x</i><code>,</code>&nbsp;<i>y</i><code>,</code>
+ * <i>width</i><code>,</code>&nbsp;<i>height</i><code>)"</code>.
+ */
+
+   std::string toString() const;
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in this class is logically part  */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+private:
+
+/* Instance variables */
+
+   double x;                       /* The x-coordinate of the rectangle */
+   double y;                       /* The y-coordinate of the rectangle */
+   double width;                   /* The width of the rectangle        */
+   double height;                  /* The height of the rectangle       */
+
+/* Friend declarations */
+
+   friend bool operator==(const GRectangle & r1, const GRectangle & r2);
+   friend bool operator!=(const GRectangle & r1, const GRectangle & r2);
+   friend int hashCode(const GRectangle & r);
+
+};
+
+/*
+ * Free functions
+ * --------------
+ * This section of the interface defines the insertion, comparison,
+ * and hashCode functions for the geometric types.
+ */
+
+std::ostream & operator<<(std::ostream & os, const GPoint & pt);
+bool operator==(const GPoint & p1, const GPoint & p2);
+bool operator!=(const GPoint & p1, const GPoint & p2);
+int hashCode(const GPoint & pt);
+
+std::ostream & operator<<(std::ostream & os, const GDimension & dim);
+bool operator==(const GDimension & d1, const GDimension & d2);
+bool operator!=(const GDimension & d1, const GDimension & d2);
+int hashCode(const GDimension & dim);
+
+std::ostream & operator<<(std::ostream & os, const GRectangle & rect);
+bool operator==(const GRectangle & r1, const GRectangle & r2);
+bool operator!=(const GRectangle & r1, const GRectangle & r2);
+int hashCode(const GRectangle & r);
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/gwindow.cpp b/labb8/lib/StanfordCPPLib/gwindow.cpp
new file mode 100755
index 0000000..30c9ea8
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/gwindow.cpp
@@ -0,0 +1,355 @@
+/*
+ * File: gwindow.cpp
+ * -----------------
+ * This file implements the GWindow class, passing most calls directly
+ * to the appropriate methods in the Platform class, which is implemented
+ * separately for each architecture.
+ */
+
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <string>
+#include "gevents.h"
+#include "gobjects.h"
+#include "gmath.h"
+#include "gtypes.h"
+#include "gwindow.h"
+#include "map.h"
+#include "strlib.h"
+#include "vector.h"
+#include "platform.h"
+using namespace std;
+
+/* Constants */
+
+static const int DEFAULT_WIDTH = 500;
+static const int DEFAULT_HEIGHT = 300;
+
+/* Private function prototypes */
+
+static void initColorTable();
+static string canonicalColorName(string str);
+
+/*
+ * Global variable: pp
+ * -------------------
+ * This variable points to a singleton of the Platform class.
+ */
+
+static Platform *pp = getPlatform();
+
+/*
+ * Global variable: colorTable
+ * ---------------------------
+ * This variable holds the translation table that maps colors into
+ * their RGB values.  This color table is shared throughout the
+ * application and cannot be manipulated by any clients.  If you
+ * need to define color names for application specific colors, you
+ * should do so by defining string constants with the appropriate
+ * hexadecimal values, as in
+ *
+ *     const string MAGENTA = "0xFF00FF";
+ */
+
+static Map<string,int> colorTable;
+
+GWindow::GWindow() {
+   initGWindow(DEFAULT_WIDTH, DEFAULT_HEIGHT, true);
+}
+
+GWindow::GWindow(bool visible) {
+   initGWindow(DEFAULT_WIDTH, DEFAULT_HEIGHT, visible);
+}
+
+GWindow::GWindow(double width, double height) {
+   initGWindow(width, height, true);
+}
+
+GWindow::GWindow(double width, double height, bool visible) {
+   initGWindow(width, height, visible);
+}
+
+void GWindow::initGWindow(double width, double height, bool visible) {
+   gwd = new GWindowData();
+   gwd->windowWidth = width;
+   gwd->windowHeight = height;
+   gwd->top = new GCompound();
+   pp->createGWindow(*this, width, height, gwd->top);
+   setColor("BLACK");
+   setVisible(visible);
+   pause(1000); // Temporary fix for race condition in back-end.
+}
+
+GWindow::~GWindow() {
+   /* Empty */
+}
+
+void GWindow::close() {
+   pp->close(*this);
+   pp->deleteGWindow(*this);
+}
+
+void GWindow::requestFocus() {
+   pp->requestFocus(*this);
+}
+
+void GWindow::clear() {
+   gwd->top->removeAll();
+   pp->clear(*this);
+}
+
+void GWindow::repaint() {
+   pp->repaint(*this);
+}
+
+void GWindow::setVisible(bool flag) {
+   gwd->visible = flag;
+   pp->setVisible(*this, flag);
+}
+
+bool GWindow::isVisible() {
+   return gwd->visible;
+}
+
+void GWindow::drawLine(const GPoint & p0, const GPoint & p1) {
+   drawLine(p0.getX(), p0.getY(), p1.getX(), p1.getY());
+}
+
+void GWindow::drawLine(double x0, double y0, double x1, double y1) {
+   GLine line(x0, y0, x1, y1);
+   line.setColor(gwd->color);
+   draw(line);
+}
+
+GPoint GWindow::drawPolarLine(const GPoint & p0, double r, double theta) {
+   return drawPolarLine(p0.getX(), p0.getY(), r, theta);
+}
+
+GPoint GWindow::drawPolarLine(double x0, double y0, double r, double theta) {
+   double x1 = x0 + r * cosDegrees(theta);
+   double y1 = y0 - r * sinDegrees(theta);
+   drawLine(x0, y0, x1, y1);
+   return GPoint(x1, y1);
+}
+
+void GWindow::drawRect(const GRectangle & bounds) {
+   drawRect(bounds.getX(), bounds.getY(), bounds.getWidth(),
+                                          bounds.getHeight());
+}
+
+void GWindow::drawRect(double x, double y, double width, double height) {
+   GRect rect(x, y, width, height);
+   rect.setColor(gwd->color);
+   draw(rect);
+}
+
+void GWindow::fillRect(const GRectangle & bounds) {
+   fillRect(bounds.getX(), bounds.getY(), bounds.getWidth(),
+                                          bounds.getHeight());
+}
+
+void GWindow::fillRect(double x, double y, double width, double height) {
+   GRect rect(x, y, width, height);
+   rect.setColor(gwd->color);
+   rect.setFilled(true);
+   draw(rect);
+}
+
+void GWindow::drawOval(const GRectangle & bounds) {
+   drawOval(bounds.getX(), bounds.getY(), bounds.getWidth(),
+                                          bounds.getHeight());
+}
+
+void GWindow::drawOval(double x, double y, double width, double height) {
+   GOval oval(x, y, width, height);
+   oval.setColor(gwd->color);
+   draw(oval);
+}
+
+void GWindow::fillOval(const GRectangle & bounds) {
+   fillOval(bounds.getX(), bounds.getY(), bounds.getWidth(),
+                                          bounds.getHeight());
+}
+
+void GWindow::fillOval(double x, double y, double width, double height) {
+   GOval oval(x, y, width, height);
+   oval.setColor(gwd->color);
+   oval.setFilled(true);
+   draw(oval);
+}
+
+void GWindow::setColor(string color) {
+   setColor(convertColorToRGB(color));
+}
+
+void GWindow::setColor(int rgb) {
+   gwd->color = convertRGBToColor(rgb);
+}
+
+string GWindow::getColor() {
+   return gwd->color;
+}
+
+double GWindow::getWidth() {
+   return gwd->windowWidth;
+}
+
+double GWindow::getHeight() {
+   return gwd->windowHeight;
+}
+
+void GWindow::setWindowTitle(string title) {
+   gwd->windowTitle = title;
+   pp->setWindowTitle(*this, title);
+}
+
+string GWindow::getWindowTitle() {
+   return gwd->windowTitle;
+}
+
+void GWindow::draw(const GObject & gobj) {
+   draw(&gobj);
+}
+
+void GWindow::draw(GObject *gobj) {
+   pp->draw(*this, gobj);
+}
+
+void GWindow::draw(const GObject *gobj) {
+   pp->draw(*this, gobj);
+}
+
+void GWindow::draw(GObject & gobj, double x, double y) {
+   draw(&gobj, x, y);
+}
+
+void GWindow::draw(GObject *gobj, double x, double y) {
+   gobj->setLocation(x, y);
+   pp->draw(*this, gobj);
+}
+
+void GWindow::add(GObject *gobj) {
+   gwd->top->add(gobj);
+}
+
+void GWindow::add(GObject *gobj, double x, double y) {
+   gobj->setLocation(x, y);
+   add(gobj);
+}
+
+void GWindow::addToRegion(GInteractor *gobj, string region) {
+   pp->addToRegion(*this, (GObject *) gobj, region);
+}
+
+void GWindow::addToRegion(GLabel *gobj, string region) {
+   pp->addToRegion(*this, (GObject *) gobj, region);
+}
+
+void GWindow::removeFromRegion(GInteractor *gobj, string region) {
+   pp->removeFromRegion(*this, (GObject *) gobj, region);
+}
+
+void GWindow::removeFromRegion(GLabel *gobj, string region) {
+   pp->removeFromRegion(*this, (GObject *) gobj, region);
+}
+
+void GWindow::remove(GObject *gobj) {
+   gwd->top->remove(gobj);
+}
+
+GObject *GWindow::getGObjectAt(double x, double y) {
+   int n = gwd->top->getElementCount();
+   for (int i = n - 1; i >= 0; i--) {
+      GObject *gobj = gwd->top->getElement(i);
+      if (gobj->contains(x, y)) return gobj;
+   }
+   return NULL;
+}
+
+void GWindow::setRegionAlignment(string region, string align) {
+   pp->setRegionAlignment(*this, region, align);
+}
+
+bool GWindow::operator==(GWindow w2) {
+   return gwd == w2.gwd;
+}
+
+bool GWindow::operator!=(GWindow w2) {
+   return gwd != w2.gwd;
+}
+
+GWindow::GWindow(GWindowData *gwd) {
+   this->gwd = gwd;
+}
+
+void pause(double milliseconds) {
+   pp->pause(milliseconds);
+}
+
+double getScreenWidth() {
+   return pp->getScreenWidth();
+}
+
+double getScreenHeight() {
+   return pp->getScreenWidth();
+}
+
+int convertColorToRGB(string colorName) {
+   if (colorName == "") return -1;
+   if (colorName[0] == '#') {
+      istringstream is(colorName.substr(1) + "@");
+      int rgb;
+      char terminator = '\0';
+      is >> hex >> rgb >> terminator;
+      if (terminator != '@') error("setColor: Illegal color - " + colorName);
+      return rgb;
+   }
+   string name = canonicalColorName(colorName);
+   if (colorTable.size() == 0) initColorTable();
+   if (!colorTable.containsKey(name)) {
+      error("setColor: Undefined color - " + colorName);
+   }
+   return colorTable[name];
+}
+
+string convertRGBToColor(int rgb) {
+   if (rgb == -1) return "";
+   ostringstream os;
+   os << hex << setfill('0') << uppercase << "#";
+   os << setw(2) << (rgb >> 16 & 0xFF);
+   os << setw(2) << (rgb >> 8 & 0xFF);
+   os << setw(2) << (rgb & 0xFF);
+   return os.str();
+}
+
+void exitGraphics() {
+   pp->exitGraphics();
+   exit(0);
+}
+
+static void initColorTable() {
+   colorTable["black"] = 0x000000;
+   colorTable["darkgray"] = 0x595959;
+   colorTable["gray"] = 0x999999;
+   colorTable["lightgray"] = 0xBFBFBF;
+   colorTable["white"] = 0xFFFFFF;
+   colorTable["red"] = 0xFF0000;
+   colorTable["yellow"] = 0xFFFF00;
+   colorTable["green"] = 0x00FF00;
+   colorTable["cyan"] = 0x00FFFF;
+   colorTable["blue"] = 0x0000FF;
+   colorTable["magenta"] = 0xFF00FF;
+   colorTable["orange"] = 0xFFC800;
+   colorTable["pink"] = 0xFFAFAF;
+}
+
+static string canonicalColorName(string str) {
+   string result = "";
+   int nChars = str.length();
+   for (int i = 0; i < nChars; i++) {
+      char ch = str[i];
+      if (!isspace(ch) && ch != '_') result += tolower(ch);
+   }
+   return result;
+}
diff --git a/labb8/lib/StanfordCPPLib/gwindow.h b/labb8/lib/StanfordCPPLib/gwindow.h
new file mode 100755
index 0000000..e6dbfbd
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/gwindow.h
@@ -0,0 +1,536 @@
+/*
+ * File: gwindow.h
+ * ---------------
+ * This file defines the <code>GWindow</code> class which supports
+ * drawing graphical objects on the screen.
+ */
+
+#ifndef _gwindow_h
+#define _gwindow_h
+
+#include <string>
+#include "gtypes.h"
+#include "vector.h"
+
+class GCompound;
+class GInteractor;
+class GLabel;
+class GObject;
+
+/*
+ * Friend type: GWindowData
+ * ------------------------
+ * This block contains all data pertaining to the window.  Shallow copying
+ * of the <code>GWindow</code> object ensures that all copies refer to the
+ * same onscreen window.
+ */
+
+struct GWindowData {
+   double windowWidth;
+   double windowHeight;
+   std::string windowTitle;
+   std::string color;
+   bool visible;
+   GCompound *top;
+};
+
+/*
+ * Class: GWindow
+ * --------------
+ * This class represents a graphics window that supports simple graphics.
+ * Each <code>GWindow</code> consists of two layers.  The background layer
+ * provides a surface for drawing static pictures that involve no animation.
+ * Graphical objects drawn in the background layer are persistent and do
+ * not require the client to update the contents of the window.  The
+ * foreground layer contains graphical objects that are redrawn as necessary.
+ *
+ * <p>The <code>GWindow</code> class includes several methods that draw
+ * lines, rectangles, and ovals on the background layer without making
+ * use of the facilities of the <code>gobjects.h</code> interface.  For
+ * example, the following program draws a diamond, rectangle, and oval
+ * at the center of the window.
+ *
+ *<pre>
+ *    int main() {
+ *       GWindow gw;
+ *       cout << "This program draws a diamond, rectangle, and oval." << endl;
+ *       double width = gw.getWidth();
+ *       double height = gw.getHeight();
+ *       gw.drawLine(0, height / 2, width / 2, 0);
+ *       gw.drawLine(width / 2, 0, width, height / 2);
+ *       gw.drawLine(width, height / 2, width / 2, height);
+ *       gw.drawLine(width / 2, height, 0, height / 2);
+ *       gw.setColor("BLUE");
+ *       gw.fillRect(width / 4, height / 4, width / 2, height / 2);
+ *       gw.setColor("GRAY");
+ *       gw.fillOval(width / 4, height / 4, width / 2, height / 2);
+ *       return 0;
+ *    }
+ *</pre>
+ *
+ * A <code>GWindow</code> object may be freely copied, after which all
+ * copies refer to the same window.
+ */
+
+class GWindow {
+
+public:
+
+/*
+ * Constructor: GWindow
+ * Usage: GWindow gw;
+ *        GWindow gw(width, height);
+ * ---------------------------------
+ * Creates a window, either of the specified size or a default size.
+ */
+
+   GWindow();
+   GWindow(double width, double height);
+
+/*
+ * Destructor: ~GWindow
+ * --------------------
+ * Reclaims the internal storage for the window.  Note that the window
+ * is not closed by this operation, but persists until it is closed by
+ * the client or the user exits the program.
+ */
+
+   virtual ~GWindow();
+
+/*
+ * Method: close
+ * Usage: gw.close();
+ * ------------------
+ * Deletes the window from the screen.
+ */
+
+   void close();
+
+/*
+ * Method: requestFocus
+ * Usage: gw.requestFocus();
+ * -------------------------
+ * Asks the system to assign the keyboard focus to the window, which
+ * brings it to the top and ensures that key events are delivered to
+ * the window.  Clicking in the window automatically requests the focus.
+ */
+
+   void requestFocus();
+
+/*
+ * Method: clear
+ * Usage: gw.clear();
+ * ------------------
+ * Clears the contents of the window.
+ */
+
+   void clear();
+
+/*
+ * Method: setVisible
+ * Usage: gw.setVisible(flag);
+ * ---------------------------
+ * Determines whether the window is visible on the screen.
+ */
+
+   void setVisible(bool flag);
+
+/*
+ * Method: isVisible
+ * Usage: if (gw.isVisible()) ...
+ * ------------------------------
+ * Tests whether the window is visible.
+ */
+
+   bool isVisible();
+
+/*
+ * Method: drawLine
+ * Usage: gw.drawLine(p0, p1);
+ *        gw.drawLine(x0, y0, x1, y1);
+ * -----------------------------------
+ * Draws a line connecting the specified points.
+ */
+
+   void drawLine(const GPoint & p0, const GPoint & p1);
+   void drawLine(double x0, double y0, double x1, double y1);
+
+/*
+ * Method: drawPolarLine
+ * Usage: GPoint p1 = gw.drawPolarLine(p0, r, theta);
+ *        GPoint p1 = gw.drawPolarLine(x0, y0, r, theta);
+ * ------------------------------------------------------
+ * Draws a line of length <code>r</code> in the direction <code>theta</code>
+ * from the initial point.  The angle <code>theta</code> is measured in
+ * degrees counterclockwise from the +<i>x</i> axis.  The method returns
+ * the end point of the line.
+ */
+
+   GPoint drawPolarLine(const GPoint & p0, double r, double theta);
+   GPoint drawPolarLine(double x0, double y0, double r, double theta);
+
+/*
+ * Method: drawOval
+ * Usage: gw.drawOval(bounds);
+ *        gw.drawOval(x, y, width, height);
+ * ----------------------------------------
+ * Draws the frame of a oval with the specified bounds.
+ */
+
+   void drawOval(const GRectangle & bounds);
+   void drawOval(double x, double y, double width, double height);
+
+/*
+ * Method: fillOval
+ * Usage: gw.fillOval(bounds);
+ *        gw.fillOval(x, y, width, height);
+ * ----------------------------------------
+ * Fills the frame of a oval with the specified bounds.
+ */
+
+   void fillOval(const GRectangle & bounds);
+   void fillOval(double x, double y, double width, double height);
+
+/*
+ * Method: drawRect
+ * Usage: gw.drawRect(bounds);
+ *        gw.drawRect(x, y, width, height);
+ * ----------------------------------------
+ * Draws the frame of a rectangle with the specified bounds.
+ */
+
+   void drawRect(const GRectangle & bounds);
+   void drawRect(double x, double y, double width, double height);
+
+/*
+ * Method: fillRect
+ * Usage: gw.fillRect(bounds);
+ *        gw.fillRect(x, y, width, height);
+ * ----------------------------------------
+ * Fills the frame of a rectangle with the specified bounds.
+ */
+
+   void fillRect(const GRectangle & bounds);
+   void fillRect(double x, double y, double width, double height);
+
+/*
+ * Method: setColor
+ * Usage: gw.setColor(color);
+ * --------------------------
+ * Sets the color used for drawing.  The <code>color</code> parameter is
+ * usually one of the predefined color names:
+ *
+ *    <code>BLACK</code>,
+ *    <code>BLUE</code>,
+ *    <code>CYAN</code>,
+ *    <code>DARK_GRAY</code>,
+ *    <code>GRAY</code>,
+ *    <code>GREEN</code>,
+ *    <code>LIGHT_GRAY</code>,
+ *    <code>MAGENTA</code>,
+ *    <code>ORANGE</code>,
+ *    <code>PINK</code>,
+ *    <code>RED</code>,
+ *    <code>WHITE</code>, and
+ *    <code>YELLOW</code>.
+ *
+ * The case of the individual letters in the color name is ignored, as
+ * are spaces and underscores, so that the color <code>DARK_GRAY</code>
+ * can be written as <code>"Dark Gray"</code>.
+ *
+ * <p>The color can also be specified as a string in the form
+ * <code>"#rrggbb"</code> where <code>rr</code>, <code>gg</code>, and
+ * <code>bb</code> are pairs of hexadecimal digits indicating the
+ * red, green, and blue components of the color.
+ */
+
+   void setColor(std::string color);
+   void setColor(int color);
+
+/*
+ * Method: getColor
+ * Usage: string color = gw.getColor();
+ * ------------------------------------
+ * Returns the current color as a string in the form <code>"#rrggbb"</code>.
+ * In this string, the values <code>rr</code>, <code>gg</code>,
+ * and <code>bb</code> are two-digit hexadecimal values representing
+ * the red, green, and blue components of the color, respectively.
+ */
+
+   std::string getColor();
+
+/*
+ * Method: getWidth
+ * Usage: double width = gw.getWidth();
+ * ------------------------------------
+ * Returns the width of the graphics window in pixels.
+ */
+
+   double getWidth();
+
+/*
+ * Method: getHeight
+ * Usage: double height = gw.getHeight();
+ * --------------------------------------
+ * Returns the height of the graphics window in pixels.
+ */
+
+   double getHeight();
+
+/*
+ * Method: repaint
+ * Usage: gw.repaint();
+ * --------------------
+ * Schedule a repaint on this window.
+ */
+
+   void repaint();
+
+/*
+ * Method: setWindowTitle
+ * Usage: gw.setWindowTitle(title);
+ * --------------------------------
+ * Sets the title of the graphics window.
+ */
+
+   void setWindowTitle(std::string title);
+
+/*
+ * Method: getWindowTitle
+ * Usage: string title = gw.getWindowTitle();
+ * ------------------------------------------
+ * Returns the title of the graphics window.
+ */
+
+   std::string getWindowTitle();
+
+/*
+ * Method: draw
+ * Usage: gw.draw(gobj);
+ *        gw.draw(gobj, x, y);
+ * ---------------------------
+ * Draws the <code>GObject</code> on the background layer.  For convenience,
+ * the <code>gobj</code> parameter may be passed either as a constant
+ * reference or as a pointer.  If the <code>x</code> and <code>y</code>
+ * parameters are included, the object is moved to that location before
+ * drawing.
+ */
+
+   void draw(const GObject & gobj);
+   void draw(GObject *gobj);
+   void draw(const GObject *gobj);
+   void draw(GObject & gobj, double x, double y);
+   void draw(GObject *gobj, double x, double y);
+
+/*
+ * Method: add
+ * Usage: gw.add(gobj);
+ *        gw.add(gobj, x, y);
+ * --------------------------
+ * Adds the <code>GObject</code> to the foreground layer of the window.
+ * The second form of the call sets the location of the object to
+ * (<code>x</code>, <code>y</code>) first.
+ *
+ * <p>In terms of memory management, adding a <code>GObject</code> pointer to
+ * a <code>GWindow</code> transfers control of that object from the client to
+ * the window manager.  Deleting a <code>GWindow</code> automatically deletes
+ * any <nobr><code>GObject</code><font size=-1>s</font></nobr> it contains.
+ */
+
+   void add(GObject *gobj);
+   void add(GObject *gobj, double x, double y);
+
+/*
+ * Method: remove
+ * Usage: gw.remove(gobj);
+ * -----------------------
+ * Removes the object from the window.
+ */
+
+   void remove(GObject *gobj);
+
+/*
+ * Method: addToRegion
+ * Usage: gw.addToRegion(interactor, region);
+ * ------------------------------------------
+ * Adds the interactor (which can also be a <code>GLabel</code>) to
+ * the control strip specified by the <code>region</code> parameter.
+ * The <code>region</code> parameter must be one of the strings
+ * <code>"NORTH"</code>, <code>"EAST"</code>, <code>"SOUTH"</code>,
+ * or <code>"WEST"</code>.
+ */
+
+   void addToRegion(GInteractor *gobj, std::string region);
+   void addToRegion(GLabel *gobj, std::string region);
+
+/*
+ * Method: removeFromRegion
+ * Usage: gw.removeFromRegion(interactor, region);
+ * -----------------------------------------------
+ * Adds the interactor (which can also be a <code>GLabel</code>) to
+ * the control strip specified by the <code>region</code> parameter.
+ * The <code>region</code> parameter must be one of the strings
+ * <code>"NORTH"</code>, <code>"EAST"</code>, <code>"SOUTH"</code>,
+ * or <code>"WEST"</code>.
+ */
+
+   void removeFromRegion(GInteractor *gobj, std::string region);
+   void removeFromRegion(GLabel *gobj, std::string region);
+
+/*
+ * Method: getGObjectAt
+ * Usage: GObject *gobj = getGObjectAt(x, y);
+ * ------------------------------------------
+ * Returns a pointer to the topmost <code>GObject</code> containing the
+ * point (<code>x</code>, <code>y</code>), or <code>NULL</code> if no such
+ * object exists.
+ */
+
+   GObject *getGObjectAt(double x, double y);
+
+/*
+ * Method: setRegionAlignment
+ * Usage: gw.setRegionAlignment(region, align);
+ * --------------------------------------------
+ * Sets the alignment of the specified side region as specified by the
+ * string <code>align</code>.  The <code>region</code> parameter must be
+ * one of the strings <code>"NORTH"</code>, <code>"EAST"</code>,
+ * <code>"SOUTH"</code>, or <code>"WEST"</code> and the <code>align</code>
+ * parameter must be <code>"LEFT"</code>, <code>"RIGHT"</code>, or
+ * <code>"CENTER"</code>.  By default, side panels use
+ * <code>CENTER</code> alignment.
+ */
+
+   void setRegionAlignment(std::string region, std::string align);
+
+/*
+ * Operator: ==
+ * Usage: if (w1 == w2) ...
+ * ------------------------
+ * Checks whether the two objects refer to the same window.
+ */
+
+   bool operator==(GWindow w2);
+
+/*
+ * Operator: !=
+ * Usage: if (w1 != w2) ...
+ * ------------------------
+ * Checks whether the two objects refer to different windows.
+ */
+
+   bool operator!=(GWindow w2);
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in the file is logically part    */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+   explicit GWindow(bool visible);
+   GWindow(double width, double height, bool visible);
+   GWindow(GWindowData *gwd);
+
+private:
+
+/* Instance variables */
+
+   GWindowData *gwd;
+
+/* Private methods */
+
+   void initGWindow(double width, double height, bool visible);
+
+   friend class Platform;
+   friend class GKeyEvent;
+   friend class GMouseEvent;
+   friend class GWindowEvent;
+
+};
+
+/*
+ * Function: repaint
+ * Usage: repaint();
+ * -----------------
+ * Issues a request to update all graphics windows.  This function
+ * is called automatically when the program pauses, waits for an
+ * event, waits for user input on the console, or terminates.  As
+ * a result, most clients never need to call repaint explicitly.
+ */
+
+void repaint();
+
+/*
+ * Function: pause
+ * Usage: pause(milliseconds);
+ * ---------------------------
+ * Pauses for the indicated number of milliseconds.  This function is
+ * useful for animation where the motion would otherwise be too fast.
+ */
+
+void pause(double milliseconds);
+
+/*
+ * Function: getScreenWidth
+ * Usage: width = getScreenWidth();
+ * --------------------------------
+ * Returns the width of the entire display screen.
+ */
+
+double getScreenWidth();
+
+/*
+ * Function: getScreenHeight
+ * Usage: height = getScreenHeight();
+ * ----------------------------------
+ * Returns the height of the entire display screen.
+ */
+
+double getScreenHeight();
+
+/*
+ * Function: convertColorToRGB
+ * Usage: int rgb = convertColorToRGB(colorName);
+ * ----------------------------------------------
+ * Converts a color name into an integer that encodes the
+ * red, green, and blue components of the color.
+ */
+
+int convertColorToRGB(std::string colorName);
+
+/*
+ * Function: convertRGBToColor
+ * Usage: int colorName = convertRGBToColor(rgb);
+ * ----------------------------------------------
+ * Converts an <code>rgb</code> value into a color name in the
+ * form <code>"#rrggbb"</code>.  Each of the <code>rr</code>,
+ * <code>gg</code>, and <code>bb</code> values are two-digit
+ * hexadecimal numbers indicating the intensity of that component.
+ */
+
+std::string convertRGBToColor(int rgb);
+
+/*
+ * Function: waitForClick
+ * Usage: waitForClick();
+ * ----------------------
+ * Waits for a mouse click to occur anywhere in any window.
+ */
+
+void waitForClick();
+
+/*
+ * Function: exitGraphics
+ * Usage: exitGraphics();
+ * ----------------------
+ * Closes all graphics windows and exits from the application without
+ * waiting for any additional user interaction.
+ */
+
+void exitGraphics();
+
+#include "console.h"
+#include "private/main.h"
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/hashmap.cpp b/labb8/lib/StanfordCPPLib/hashmap.cpp
new file mode 100755
index 0000000..4dd77d6
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/hashmap.cpp
@@ -0,0 +1,296 @@
+/*
+ * File: hashmap.cpp
+ * -----------------
+ * This file contains the hash functions that are used in conjunction
+ * with the HashMap class.
+ */
+
+#include <iostream>
+#include <string>
+#include "hashmap.h"
+#include "hashset.h"
+#include "lexicon.h"
+#include "queue.h"
+#include "set.h"
+#include "stack.h"
+#include "vector.h"
+using namespace std;
+
+/*
+ * Implementation notes: hashCode
+ * ------------------------------
+ * This function takes a string key and uses it to derive a hash code,
+ * which is a nonnegative integer related to the key by a deterministic
+ * function that distributes keys well across the space of integers.
+ * The general method is called linear congruence, which is also used
+ * in random-number generators.  The specific algorithm used here is
+ * called djb2 after the initials of its inventor, Daniel J. Bernstein,
+ * Professor of Mathematics at the University of Illinois at Chicago.
+ */
+
+const int HASH_SEED = 5381;               /* Starting point for first cycle */
+const int HASH_MULTIPLIER = 33;           /* Multiplier for each cycle      */
+const int HASH_MASK = unsigned(-1) >> 1;  /* All 1 bits except the sign     */
+
+int hashCode(const string & str) {
+   unsigned hash = HASH_SEED;
+   int n = str.length();
+   for (int i = 0; i < n; i++) {
+      hash = HASH_MULTIPLIER * hash + str[i];
+   }
+   return int(hash & HASH_MASK);
+}
+
+int hashCode(int key) {
+   return key & HASH_MASK;
+}
+
+int hashCode(char key) {
+   return key;
+}
+
+int hashCode(long key) {
+   return int(key) & HASH_MASK;
+}
+
+int hashCode(double key) {
+    char* byte = (char*) &key;
+    unsigned hash = HASH_SEED;
+    for (int i = 0; i < (int) sizeof(double); i++) {
+        hash = HASH_MULTIPLIER * hash + (int) *byte++;
+    }
+    return hash & HASH_MASK;
+}
+
+
+// hashCode functions for various collections;
+// added by Marty Stepp to allow compound collections.
+// I'm a bit ashamed to have to rewrite so many prototypes, one for each
+// element type; but I can't get it to compile with a template.
+int hashCode(const HashSet<int>& s) {
+    int code = HASH_SEED;
+    foreach (int n in s) {
+        code = HASH_MULTIPLIER * code + hashCode(n);
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const HashSet<double>& s) {
+    int code = HASH_SEED;
+    foreach (double n in s) {
+        code = HASH_MULTIPLIER * code + hashCode(n);
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const HashSet<char>& s) {
+    int code = HASH_SEED;
+    foreach (char n in s) {
+        code = HASH_MULTIPLIER * code + hashCode(n);
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const HashSet<long>& s) {
+    int code = HASH_SEED;
+    foreach (long n in s) {
+        code = HASH_MULTIPLIER * code + hashCode(n);
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const HashSet<std::string>& s) {
+    int code = HASH_SEED;
+    foreach (std::string n in s) {
+        code = HASH_MULTIPLIER * code + hashCode(n);
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Lexicon& l) {
+    int code = HASH_SEED;
+    foreach (std::string n in l) {
+        code = HASH_MULTIPLIER * code + hashCode(n);
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Queue<int>& q) {
+    int code = HASH_SEED;
+    Queue<int> backup = q;
+    while (!backup.isEmpty()) {
+        code = HASH_MULTIPLIER * code + hashCode(backup.dequeue());
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Queue<double>& q) {
+    int code = HASH_SEED;
+    Queue<double> backup = q;
+    while (!backup.isEmpty()) {
+        code = HASH_MULTIPLIER * code + hashCode(backup.dequeue());
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Queue<char>& q) {
+    int code = HASH_SEED;
+    Queue<char> backup = q;
+    while (!backup.isEmpty()) {
+        code = HASH_MULTIPLIER * code + hashCode(backup.dequeue());
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Queue<long>& q) {
+    int code = HASH_SEED;
+    Queue<long> backup = q;
+    while (!backup.isEmpty()) {
+        code = HASH_MULTIPLIER * code + hashCode(backup.dequeue());
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Queue<std::string>& q) {
+    int code = HASH_SEED;
+    Queue<std::string> backup = q;
+    while (!backup.isEmpty()) {
+        code = HASH_MULTIPLIER * code + hashCode(backup.dequeue());
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Set<int>& s) {
+    int code = HASH_SEED;
+    foreach (int n in s) {
+        code = HASH_MULTIPLIER * code + hashCode(n);
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Set<double>& s) {
+    int code = HASH_SEED;
+    foreach (double n in s) {
+        code = HASH_MULTIPLIER * code + hashCode(n);
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Set<char>& s) {
+    int code = HASH_SEED;
+    foreach (char n in s) {
+        code = HASH_MULTIPLIER * code + hashCode(n);
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Set<long>& s) {
+    int code = HASH_SEED;
+    foreach (long n in s) {
+        code = HASH_MULTIPLIER * code + hashCode(n);
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Set<std::string>& s) {
+    int code = HASH_SEED;
+    foreach (std::string n in s) {
+        code = HASH_MULTIPLIER * code + hashCode(n);
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Stack<int>& s) {
+    int code = HASH_SEED;
+    Stack<int> backup = s;
+    while (!backup.isEmpty()) {
+        code = HASH_MULTIPLIER * code + hashCode(backup.pop());
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Stack<double>& s) {
+    int code = HASH_SEED;
+    Stack<double> backup = s;
+    while (!backup.isEmpty()) {
+        code = HASH_MULTIPLIER * code + hashCode(backup.pop());
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Stack<char>& s) {
+    int code = HASH_SEED;
+    Stack<char> backup = s;
+    while (!backup.isEmpty()) {
+        code = HASH_MULTIPLIER * code + hashCode(backup.pop());
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Stack<long>& s) {
+    int code = HASH_SEED;
+    Stack<long> backup = s;
+    while (!backup.isEmpty()) {
+        code = HASH_MULTIPLIER * code + hashCode(backup.pop());
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Stack<std::string>& s) {
+    int code = HASH_SEED;
+    Stack<std::string> backup = s;
+    while (!backup.isEmpty()) {
+        code = HASH_MULTIPLIER * code + hashCode(backup.pop());
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Vector<int>& v) {
+    int code = HASH_SEED;
+    for (int i = 0, size = v.size(); i < size; i++) {
+        code = HASH_MULTIPLIER * code + hashCode(v[i]);
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Vector<double>& v) {
+    int code = HASH_SEED;
+    for (int i = 0, size = v.size(); i < size; i++) {
+        code = HASH_MULTIPLIER * code + hashCode(v[i]);
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Vector<char>& v) {
+    int code = HASH_SEED;
+    for (int i = 0, size = v.size(); i < size; i++) {
+        code = HASH_MULTIPLIER * code + hashCode(v[i]);
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Vector<long>& v) {
+    int code = HASH_SEED;
+    for (int i = 0, size = v.size(); i < size; i++) {
+        code = HASH_MULTIPLIER * code + hashCode(v[i]);
+    }
+    return int(code & HASH_MASK);
+}
+
+int hashCode(const Vector<std::string>& v) {
+    int code = HASH_SEED;
+    for (int i = 0, size = v.size(); i < size; i++) {
+        code = HASH_MULTIPLIER * code + hashCode(v[i]);
+    }
+    return int(code & HASH_MASK);
+}
+
+//template <typename ValueType>
+//int hashCode(const Vector<ValueType>& v) {
+//    int code = 0;
+//    for (int i = 0, size = v.size(); i < size; i++) {
+//        code = 31 * code + hashCode(v[i]);
+//    }
+//    return code;
+//}
+
diff --git a/labb8/lib/StanfordCPPLib/hashmap.h b/labb8/lib/StanfordCPPLib/hashmap.h
new file mode 100755
index 0000000..5b76ae0
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/hashmap.h
@@ -0,0 +1,663 @@
+/*
+ * File: hashmap.h
+ * ---------------
+ * This file exports the <code>HashMap</code> class, which stores
+ * a set of <i>key</i>-<i>value</i> pairs.
+ */
+
+#ifndef _hashmap_h
+#define _hashmap_h
+
+#include <cstdlib>
+#include <string>
+#include "foreach.h"
+#include "vector.h"
+
+/*
+ * Function: hashCode
+ * Usage: int hash = hashCode(key);
+ * --------------------------------
+ * Returns a hash code for the specified key, which is always a
+ * nonnegative integer.  This function is overloaded to support
+ * all of the primitive types and the C++ <code>string</code> type.
+ */
+
+int hashCode(const std::string & key);
+int hashCode(int key);
+int hashCode(char key);
+int hashCode(long key);
+int hashCode(double key);
+
+/*
+ * Class: HashMap<KeyType,ValueType>
+ * ---------------------------------
+ * This class implements an efficient association between
+ * <b><i>keys</i></b> and <b><i>values</i></b>.  This class is
+ * identical to the <a href="Map-class.html"><code>Map</code></a> class
+ * except for the fact that it uses a hash table as its underlying
+ * representation.  Although the <code>HashMap</code> class operates in
+ * constant time, the iterator for <code>HashMap</code> returns the
+ * values in a seemingly random order.
+ */
+
+template <typename KeyType, typename ValueType>
+class HashMap {
+
+public:
+
+/*
+ * Constructor: HashMap
+ * Usage: HashMap<KeyType,ValueType> map;
+ * --------------------------------------
+ * Initializes a new empty map that associates keys and values of
+ * the specified types.  The type used for the key must define
+ * the <code>==</code> operator, and there must be a free function
+ * with the following signature:
+ *
+ *<pre>
+ *    int hashCode(KeyType key);
+ *</pre>
+ *
+ * that returns a positive integer determined by the key.  This interface
+ * exports <code>hashCode</code> functions for <code>string</code> and
+ * the C++ primitive types.
+ */
+
+   HashMap();
+
+/*
+ * Destructor: ~HashMap
+ * --------------------
+ * Frees any heap storage associated with this map.
+ */
+
+   virtual ~HashMap();
+
+/*
+ * Method: size
+ * Usage: int nEntries = map.size();
+ * ---------------------------------
+ * Returns the number of entries in this map.
+ */
+
+   int size() const;
+
+/*
+ * Method: isEmpty
+ * Usage: if (map.isEmpty()) ...
+ * -----------------------------
+ * Returns <code>true</code> if this map contains no entries.
+ */
+
+   bool isEmpty() const;
+
+/*
+ * Method: put
+ * Usage: map.put(key, value);
+ * ---------------------------
+ * Associates <code>key</code> with <code>value</code> in this map.
+ * Any previous value associated with <code>key</code> is replaced
+ * by the new value.
+ */
+
+   void put(KeyType key, ValueType value);
+
+/*
+ * Method: get
+ * Usage: ValueType value = map.get(key);
+ * --------------------------------------
+ * Returns the value associated with <code>key</code> in this map.
+ * If <code>key</code> is not found, <code>get</code> returns the
+ * default value for <code>ValueType</code>.
+ */
+
+   ValueType get(KeyType key) const;
+
+/*
+ * Method: containsKey
+ * Usage: if (map.containsKey(key)) ...
+ * ------------------------------------
+ * Returns <code>true</code> if there is an entry for <code>key</code>
+ * in this map.
+ */
+
+   bool containsKey(KeyType key) const;
+
+/*
+ * Method: remove
+ * Usage: map.remove(key);
+ * -----------------------
+ * Removes any entry for <code>key</code> from this map.
+ */
+
+   void remove(KeyType key);
+
+/*
+ * Method: clear
+ * Usage: map.clear();
+ * -------------------
+ * Removes all entries from this map.
+ */
+
+   void clear();
+
+/*
+ * Method: keys
+ * Usage: Vector<KeyType> keys = map.keys();
+ * -------------------------------------------
+ * Returns a collection containing all keys in this map.
+ */
+
+   Vector<KeyType> keys() const;
+
+/*
+ * Method: values
+ * Usage: Vector<ValueType> values = map.values();
+ * -------------------------------------------
+ * Returns a collection containing all values in this map.
+ */
+
+   Vector<ValueType> values() const;
+
+/*
+ * Operator: []
+ * Usage: map[key]
+ * ---------------
+ * Selects the value associated with <code>key</code>.  This syntax
+ * makes it easy to think of a map as an "associative array"
+ * indexed by the key type.  If <code>key</code> is already present
+ * in the map, this function returns a reference to its associated
+ * value.  If key is not present in the map, a new entry is created
+ * whose value is set to the default for the value type.
+ */
+
+   ValueType & operator[](KeyType key);
+   ValueType operator[](KeyType key) const;
+
+/*
+ * Method: toString
+ * Usage: string str = map.toString();
+ * -----------------------------------
+ * Converts the map to a printable string representation.
+ */
+
+   std::string toString();
+
+/*
+ * Method: mapAll
+ * Usage: map.mapAll(fn);
+ * ----------------------
+ * Iterates through the map entries and calls <code>fn(key, value)</code>
+ * for each one.  The keys are processed in an undetermined order.
+ */
+
+   void mapAll(void (*fn)(KeyType, ValueType)) const;
+   void mapAll(void (*fn)(const KeyType &, const ValueType &)) const;
+   template <typename FunctorType>
+   void mapAll(FunctorType fn) const;
+
+/*
+ * Additional HashMap operations
+ * -----------------------------
+ * In addition to the methods listed in this interface, the HashMap
+ * class supports the following operations:
+ *
+ *   - Stream I/O using the << and >> operators
+ *   - Deep copying for the copy constructor and assignment operator
+ *   - Iteration using the range-based for statement and STL iterators
+ *
+ * The HashMap class makes no guarantees about the order of iteration.
+ */
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in the file is logically part    */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+/*
+ * Implementation notes:
+ * ---------------------
+ * The HashMap class is represented using a hash table that uses
+ * bucket chaining to resolve collisions.
+ */
+
+private:
+
+/* Constant definitions */
+
+   static const int INITIAL_BUCKET_COUNT = 101;
+   static const int MAX_LOAD_PERCENTAGE = 70;
+
+/* Type definition for cells in the bucket chain */
+
+   struct Cell {
+      KeyType key;
+      ValueType value;
+      Cell *next;
+   };
+
+/* Instance variables */
+
+   Vector<Cell *> buckets;
+   int nBuckets;
+   int numEntries;
+
+/* Private methods */
+
+/*
+ * Private method: createBuckets
+ * Usage: createBuckets(nBuckets);
+ * -------------------------------
+ * Sets up the vector of buckets to have nBuckets entries, each NULL.
+ * If asked to make empty vector, makes one bucket just to simplify
+ * handling elsewhere.
+ */
+
+   void createBuckets(int nBuckets) {
+      if (nBuckets == 0) nBuckets = 1;
+      buckets = Vector<Cell *>(nBuckets, NULL);
+      this->nBuckets = nBuckets;
+      numEntries = 0;
+   }
+
+/*
+ * Private method: deleteBuckets
+ * Usage: deleteBuckets(buckets);
+ * ------------------------------
+ * Deletes all the cells in the linked lists contained in vector.
+ */
+
+   void deleteBuckets(Vector <Cell *> & buckets) {
+      for (int i = 0; i < buckets.size(); i++) {
+         Cell *cp = buckets[i];
+         while (cp != NULL) {
+            Cell *np = cp->next;
+            delete cp;
+            cp = np;
+         }
+         buckets[i] = NULL;
+      }
+   }
+
+/*
+ * Private method: expandAndRehash
+ * Usage: expandAndRehash();
+ * -------------------------
+ * This method is used to increase the number of buckets in the map
+ * and then rehashes all existing entries and adds them into new buckets.
+ * This operation is used when the load factor (i.e. the number of cells
+ * per bucket) has increased enough to warrant this O(N) operation to
+ * enlarge and redistribute the entries.
+ */
+
+   void expandAndRehash() {
+      Vector<Cell *>oldBuckets = buckets;
+      createBuckets(oldBuckets.size() * 2 + 1);
+      for (int i = 0; i < oldBuckets.size(); i++) {
+         for (Cell *cp = oldBuckets[i]; cp != NULL; cp = cp->next) {
+            put(cp->key, cp->value);
+         }
+      }
+      deleteBuckets(oldBuckets);
+   }
+
+/*
+ * Private method: findCell
+ * Usage: Cell *cp = findCell(bucket, key);
+ *        Cell *cp = findCell(bucket, key, parent);
+ * ------------------------------------------------
+ * Finds a cell in the chain for the specified bucket that matches key.
+ * If a match is found, the return value is a pointer to the cell containing
+ * the matching key.  If no match is found, the function returns NULL.
+ * If the optional third argument is supplied, it is filled in with the
+ * cell preceding the matching cell to allow the client to splice out
+ * the target cell in the delete call.  If parent is NULL, it indicates
+ * that the cell is the first cell in the bucket chain.
+ */
+
+   Cell *findCell(int bucket, KeyType key) const {
+      Cell *dummy;
+      return findCell(bucket, key, dummy);
+   }
+
+   Cell *findCell(int bucket, KeyType key, Cell * & parent) const {
+      parent = NULL;
+      Cell *cp = buckets.get(bucket);
+      while (cp != NULL && key != cp->key) {
+         parent = cp;
+         cp = cp->next;
+      }
+      return cp;
+   }
+
+   void deepCopy(const HashMap & src) {
+      createBuckets(src.nBuckets);
+      for (int i = 0; i < src.nBuckets; i++) {
+         for (Cell *cp = src.buckets.get(i); cp != NULL; cp = cp->next) {
+            put(cp->key, cp->value);
+         }
+      }
+   }
+
+public:
+
+/*
+ * Hidden features
+ * ---------------
+ * The remainder of this file consists of the code required to
+ * support deep copying and iteration.  Including these methods
+ * in the public interface would make that interface more
+ * difficult to understand for the average client.
+ */
+
+/*
+ * Deep copying support
+ * --------------------
+ * This copy constructor and operator= are defined to make a
+ * deep copy, making it possible to pass/return maps by value
+ * and assign from one map to another.
+ */
+
+   HashMap & operator=(const HashMap & src) {
+      if (this != &src) {
+         clear();
+         deepCopy(src);
+      }
+      return *this;
+   }
+
+   HashMap(const HashMap & src) {
+      deepCopy(src);
+   }
+
+/*
+ * Iterator support
+ * ----------------
+ * The classes in the StanfordCPPLib collection implement input
+ * iterators so that they work symmetrically with respect to the
+ * corresponding STL classes.
+ */
+
+   class iterator : public std::iterator<std::input_iterator_tag,KeyType> {
+
+   private:
+
+      const HashMap *mp;           /* Pointer to the map           */
+      int bucket;                  /* Index of current bucket      */
+      Cell *cp;                    /* Current cell in bucket chain */
+
+   public:
+
+      iterator() {
+        /* Empty */
+      }
+
+      iterator(const HashMap *mp, bool end) {
+         this->mp = mp;
+         if (end) {
+            bucket = mp->nBuckets;
+            cp = NULL;
+         } else {
+            bucket = 0;
+            cp = mp->buckets.get(bucket);
+            while (cp == NULL && ++bucket < mp->nBuckets) {
+               cp = mp->buckets.get(bucket);
+            }
+         }
+      }
+
+      iterator(const iterator & it) {
+         mp = it.mp;
+         bucket = it.bucket;
+         cp = it.cp;
+      }
+
+      iterator & operator++() {
+         cp = cp->next;
+         while (cp == NULL && ++bucket < mp->nBuckets) {
+            cp = mp->buckets.get(bucket);
+         }
+         return *this;
+      }
+
+      iterator operator++(int) {
+         iterator copy(*this);
+         operator++();
+         return copy;
+      }
+
+      bool operator==(const iterator & rhs) {
+         return mp == rhs.mp && bucket == rhs.bucket && cp == rhs.cp;
+      }
+
+      bool operator!=(const iterator & rhs) {
+         return !(*this == rhs);
+      }
+
+      KeyType operator*() {
+         return cp->key;
+      }
+
+      KeyType *operator->() {
+         return &cp->key;
+      }
+
+      friend class HashMap;
+
+   };
+
+   iterator begin() const {
+      return iterator(this, false);
+   }
+
+   iterator end() const {
+      return iterator(this, true);
+   }
+
+};
+
+/*
+ * Implementation notes: HashMap class
+ * -----------------------------------
+ * In this map implementation, the entries are stored in a hashtable.
+ * The hashtable keeps a vector of "buckets", where each bucket is a
+ * linked list of elements that share the same hash code (i.e. hash
+ * collisions are resolved by chaining). The buckets are dynamically
+ * allocated so that we can change the the number of buckets (rehash)
+ * when the load factor becomes too high. The map should provide O(1)
+ * performance on the put/remove/get operations.
+ */
+
+template <typename KeyType,typename ValueType>
+HashMap<KeyType,ValueType>::HashMap() {
+   createBuckets(INITIAL_BUCKET_COUNT);
+}
+
+template <typename KeyType,typename ValueType>
+HashMap<KeyType,ValueType>::~HashMap() {
+   deleteBuckets(buckets);
+}
+
+template <typename KeyType,typename ValueType>
+int HashMap<KeyType,ValueType>::size() const {
+   return numEntries;
+}
+
+template <typename KeyType,typename ValueType>
+bool HashMap<KeyType,ValueType>::isEmpty() const {
+   return size() == 0;
+}
+
+template <typename KeyType,typename ValueType>
+void HashMap<KeyType,ValueType>::put(KeyType key, ValueType value) {
+   (*this)[key] = value;
+}
+
+template <typename KeyType,typename ValueType>
+ValueType HashMap<KeyType,ValueType>::get(KeyType key) const {
+   Cell *cp = findCell(hashCode(key) % nBuckets, key);
+   if (cp == NULL) return ValueType();
+   return cp->value;
+}
+
+template <typename KeyType,typename ValueType>
+bool HashMap<KeyType,ValueType>::containsKey(KeyType key) const {
+   return findCell(hashCode(key) % nBuckets, key) != NULL;
+}
+
+template <typename KeyType,typename ValueType>
+void HashMap<KeyType,ValueType>::remove(KeyType key) {
+   int bucket = hashCode(key) % nBuckets;
+   Cell *parent;
+   Cell *cp = findCell(bucket, key, parent);
+   if (cp != NULL) {
+      if (parent == NULL) {
+         buckets[bucket] = cp->next;
+      } else {
+         parent->next = cp->next;
+      }
+      delete cp;
+      numEntries--;
+   }
+}
+
+template <typename KeyType,typename ValueType>
+void HashMap<KeyType,ValueType>::clear() {
+   deleteBuckets(buckets);
+   numEntries = 0;
+}
+
+template <typename KeyType,typename ValueType>
+Vector<KeyType> HashMap<KeyType,ValueType>::keys() const {
+   Vector<KeyType> keyset;
+   foreach (KeyType key in *this) {
+       keyset.add(key);
+   }
+   return keyset;
+}
+
+template <typename KeyType,typename ValueType>
+Vector<ValueType> HashMap<KeyType,ValueType>::values() const {
+   Vector<ValueType> values;
+   foreach (KeyType key in *this) {
+       values.add(this->get(key));
+   }
+   return values;
+}
+
+template <typename KeyType,typename ValueType>
+ValueType & HashMap<KeyType,ValueType>::operator[](KeyType key) {
+   int bucket = hashCode(key) % nBuckets;
+   Cell *cp = findCell(bucket, key);
+   if (cp == NULL) {
+      if (numEntries > MAX_LOAD_PERCENTAGE * nBuckets / 100.0) {
+         expandAndRehash();
+         bucket = hashCode(key) % nBuckets;
+      }
+      cp = new Cell;
+      cp->key = key;
+      cp->value = ValueType();
+      cp->next = buckets[bucket];
+      buckets[bucket] = cp;
+      numEntries++;
+   }
+   return cp->value;
+}
+
+template <typename KeyType,typename ValueType>
+void HashMap<KeyType,ValueType>::mapAll(void (*fn)(KeyType, ValueType)) const {
+   for (int i = 0 ; i < buckets.size(); i++) {
+      for (Cell *cp = buckets.get(i); cp != NULL; cp = cp->next) {
+         fn(cp->key, cp->value);
+      }
+   }
+}
+
+template <typename KeyType,typename ValueType>
+void HashMap<KeyType,ValueType>::mapAll(void (*fn)(const KeyType &,
+                                                   const ValueType &)) const {
+   for (int i = 0 ; i < buckets.size(); i++) {
+      for (Cell *cp = buckets.get(i); cp != NULL; cp = cp->next) {
+         fn(cp->key, cp->value);
+      }
+   }
+}
+
+template <typename KeyType,typename ValueType>
+template <typename FunctorType>
+void HashMap<KeyType,ValueType>::mapAll(FunctorType fn) const {
+   for (int i = 0 ; i < buckets.size(); i++) {
+      for (Cell *cp = buckets.get(i); cp != NULL; cp = cp->next) {
+         fn(cp->key, cp->value);
+      }
+   }
+}
+
+template <typename KeyType, typename ValueType>
+ValueType HashMap<KeyType,ValueType>::operator[](KeyType key) const {
+   return get(key);
+}
+
+template <typename KeyType, typename ValueType>
+std::string HashMap<KeyType,ValueType>::toString() {
+   ostringstream os;
+   os << *this;
+   return os.str();
+}
+
+/*
+ * Implementation notes: << and >>
+ * -------------------------------
+ * The insertion and extraction operators use the template facilities in
+ * strlib.h to read and write generic values in a way that treats strings
+ * specially.
+ */
+
+template <typename KeyType, typename ValueType>
+std::ostream & operator<<(std::ostream & os,
+                          const HashMap<KeyType,ValueType> & map) {
+   os << "{";
+   typename HashMap<KeyType,ValueType>::iterator begin = map.begin();
+   typename HashMap<KeyType,ValueType>::iterator end = map.end();
+   typename HashMap<KeyType,ValueType>::iterator it = begin;
+   while (it != end) {
+      if (it != begin) os << ", ";
+      writeGenericValue(os, *it, false);
+      os << ":";
+      writeGenericValue(os, map[*it], false);
+      ++it;
+   }
+   return os << "}";
+}
+
+template <typename KeyType, typename ValueType>
+std::istream & operator>>(std::istream & is,
+                          HashMap<KeyType,ValueType> & map) {
+   char ch;
+   is >> ch;
+   if (ch != '{') error("operator >>: Missing {");
+   map.clear();
+   is >> ch;
+   if (ch != '}') {
+      is.unget();
+      while (true) {
+         KeyType key;
+         readGenericValue(is, key);
+         is >> ch;
+         if (ch != ':') error("operator >>: Missing colon after key");
+         ValueType value;
+         readGenericValue(is, value);
+         map[key] = value;
+         is >> ch;
+         if (ch == '}') break;
+         if (ch != ',') {
+            error(std::string("operator >>: Unexpected character ") + ch);
+         }
+      }
+   }
+   return is;
+}
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/hashset.h b/labb8/lib/StanfordCPPLib/hashset.h
new file mode 100755
index 0000000..f7551c5
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/hashset.h
@@ -0,0 +1,613 @@
+/*
+ * File: hashset.h
+ * ---------------
+ * This file exports the <code>HashSet</code> class, which
+ * implements an efficient abstraction for storing sets of values.
+ */
+
+#ifndef _hashset_h
+#define _hashset_h
+
+#include <iostream>
+#include "foreach.h"
+#include "hashmap.h"
+#include "vector.h"
+
+/*
+ * Class: HashSet<ValueType>
+ * -------------------------
+ * This class implements an efficient abstraction for storing sets
+ * of distinct elements.  This class is identical to the <code>Set</code>
+ * class except for the fact that it uses a hash table as its underlying
+ * representation.  The advantage of the <code>HashSet</code> class is that
+ * it operates in constant time, as opposed to the <i>O</i>(log <i>N</i>)
+ * time for the <code>Set</code> class.  The disadvantage of
+ * <code>HashSet</code> is that iterators return the values in a
+ * seemingly random order.
+ */
+
+template <typename ValueType>
+class HashSet {
+
+public:
+
+/*
+ * Constructor: HashSet
+ * Usage: HashSet<ValueType> set;
+ * ------------------------------
+ * Initializes an empty set of the specified element type.
+ */
+
+   HashSet();
+
+/*
+ * Destructor: ~HashSet
+ * --------------------
+ * Frees any heap storage associated with this set.
+ */
+
+   virtual ~HashSet();
+
+/*
+ * Method: size
+ * Usage: count = set.size();
+ * --------------------------
+ * Returns the number of elements in this set.
+ */
+
+   int size() const;
+
+/*
+ * Method: isEmpty
+ * Usage: if (set.isEmpty()) ...
+ * -----------------------------
+ * Returns <code>true</code> if this set contains no elements.
+ */
+
+   bool isEmpty() const;
+
+/*
+ * Method: add
+ * Usage: set.add(value);
+ * ----------------------
+ * Adds an element to this set, if it was not already there.  For
+ * compatibility with the STL <code>set</code> class, this method
+ * is also exported as <code>insert</code>.
+ */
+
+   void add(const ValueType & value);
+   void insert(const ValueType & value);
+
+/*
+ * Method: remove
+ * Usage: set.remove(value);
+ * -------------------------
+ * Removes an element from this set.  If the value was not
+ * contained in the set, no error is generated and the set
+ * remains unchanged.
+ */
+
+   void remove(const ValueType & value);
+
+/*
+ * Method: contains
+ * Usage: if (set.contains(value)) ...
+ * -----------------------------------
+ * Returns <code>true</code> if the specified value is in this set.
+ */
+
+   bool contains(const ValueType & value) const;
+
+/*
+ * Method: isSubsetOf
+ * Usage: if (set.isSubsetOf(set2)) ...
+ * ------------------------------------
+ * Implements the subset relation on sets.  It returns
+ * <code>true</code> if every element of this set is
+ * contained in <code>set2</code>.
+ */
+
+   bool isSubsetOf(const HashSet & set2) const;
+
+/*
+ * Method: clear
+ * Usage: set.clear();
+ * -------------------
+ * Removes all elements from this set.
+ */
+
+   void clear();
+
+/*
+ * Operator: ==
+ * Usage: set1 == set2
+ * -------------------
+ * Returns <code>true</code> if <code>set1</code> and <code>set2</code>
+ * contain the same elements.
+ */
+
+   bool operator==(const HashSet & set2) const;
+
+/*
+ * Operator: !=
+ * Usage: set1 != set2
+ * -------------------
+ * Returns <code>true</code> if <code>set1</code> and <code>set2</code>
+ * are different.
+ */
+
+   bool operator!=(const HashSet & set2) const;
+
+/*
+ * Operator: +
+ * Usage: set1 + set2
+ *        set1 + element
+ * ---------------------
+ * Returns the union of sets <code>set1</code> and <code>set2</code>, which
+ * is the set of elements that appear in at least one of the two sets.  The
+ * right hand set can be replaced by an element of the value type, in which
+ * case the operator returns a new set formed by adding that element.
+ */
+
+   HashSet operator+(const HashSet & set2) const;
+   HashSet operator+(const ValueType & element) const;
+
+/*
+ * Operator: *
+ * Usage: set1 * set2
+ * ------------------
+ * Returns the intersection of sets <code>set1</code> and <code>set2</code>,
+ * which is the set of all elements that appear in both.
+ */
+
+   HashSet operator*(const HashSet & set2) const;
+
+/*
+ * Operator: -
+ * Usage: set1 - set2
+ *        set1 - element
+ * ---------------------
+ * Returns the difference of sets <code>set1</code> and <code>set2</code>,
+ * which is all of the elements that appear in <code>set1</code> but
+ * not <code>set2</code>.  The right hand set can be replaced by an
+ * element of the value type, in which case the operator returns a new
+ * set formed by removing that element.
+ */
+
+   HashSet operator-(const HashSet & set2) const;
+   HashSet operator-(const ValueType & element) const;
+
+/*
+ * Operator: +=
+ * Usage: set1 += set2;
+ *        set1 += value;
+ * ---------------------
+ * Adds all of the elements from <code>set2</code> (or the single
+ * specified value) to <code>set1</code>.  As a convenience, the
+ * <code>HashSet</code> package also overloads the comma operator so
+ * that it is possible to initialize a set like this:
+ *
+ *<pre>
+ *    HashSet&lt;int&lt; digits;
+ *    digits += 0, 1, 2, 3, 4, 5, 6, 7, 8, 9;
+ *</pre>
+ */
+
+   HashSet & operator+=(const HashSet & set2);
+   HashSet & operator+=(const ValueType & value);
+
+/*
+ * Operator: *=
+ * Usage: set1 *= set2;
+ * --------------------
+ * Removes any elements from <code>set1</code> that are not present in
+ * <code>set2</code>.
+ */
+
+   HashSet & operator*=(const HashSet & set2);
+
+/*
+ * Operator: -=
+ * Usage: set1 -= set2;
+ *        set1 -= value;
+ * ---------------------
+ * Removes the elements from <code>set2</code> (or the single
+ * specified value) from <code>set1</code>.  As a convenience, the
+ * <code>HashSet</code> package also overloads the comma operator so
+ * that it is possible to remove multiple elements from a set
+ * like this:
+ *
+ *<pre>
+ *    digits -= 0, 2, 4, 6, 8;
+ *</pre>
+ *
+ * which removes the values 0, 2, 4, 6, and 8 from the set
+ * <code>digits</code>.
+ */
+
+   HashSet & operator-=(const HashSet & set2);
+   HashSet & operator-=(const ValueType & value);
+
+/*
+ * Method: first
+ * Usage: ValueType value = set.first();
+ * -------------------------------------
+ * Returns the first value in the set in the order established by the
+ * <code>foreach</code> macro.  If the set is empty, <code>first</code>
+ * generates an error.
+ */
+
+   ValueType first() const;
+
+/*
+ * Method: toString
+ * Usage: string str = set.toString();
+ * -----------------------------------
+ * Converts the set to a printable string representation.
+ */
+
+   std::string toString();
+
+/*
+ * Method: mapAll
+ * Usage: set.mapAll(fn);
+ * ----------------------
+ * Iterates through the elements of the set and calls <code>fn(value)</code>
+ * for each one.  The values are processed in ascending order, as defined
+ * by the comparison function.
+ */
+
+   void mapAll(void (*fn)(ValueType)) const;
+   void mapAll(void (*fn)(const ValueType &)) const;
+
+   template <typename FunctorType>
+   void mapAll(FunctorType fn) const;
+
+/*
+ * Additional HashSet operations
+ * -----------------------------
+ * In addition to the methods listed in this interface, the HashSet
+ * class supports the following operations:
+ *
+ *   - Stream I/O using the << and >> operators
+ *   - Deep copying for the copy constructor and assignment operator
+ *   - Iteration using the range-based for statement and STL iterators
+ *
+ * The iteration forms process the HashSet in an unspecified order.
+ */
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in the file is logically part    */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+private:
+
+   HashMap<ValueType,bool> map;        /* Map used to store the element     */
+   bool removeFlag;                    /* Flag to differentiate += and -=   */
+
+public:
+
+/*
+ * Hidden features
+ * ---------------
+ * The remainder of this file consists of the code required to
+ * support the comma operator, deep copying, and iteration.
+ * Including these methods in the public interface would make
+ * that interface more difficult to understand for the average client.
+ */
+
+   HashSet & operator,(const ValueType & value) {
+      if (this->removeFlag) {
+         this->remove(value);
+      } else {
+         this->add(value);
+      }
+      return *this;
+   }
+
+/*
+ * Iterator support
+ * ----------------
+ * The classes in the StanfordCPPLib collection implement input
+ * iterators so that they work symmetrically with respect to the
+ * corresponding STL classes.
+ */
+
+   class iterator : public std::iterator<std::input_iterator_tag,ValueType> {
+
+   private:
+
+      typename HashMap<ValueType,bool>::iterator mapit;
+
+   public:
+
+      iterator() {
+         /* Empty */
+      }
+
+      iterator(typename HashMap<ValueType,bool>::iterator it) : mapit(it) {
+         /* Empty */
+      }
+
+      iterator(const iterator & it) {
+         mapit = it.mapit;
+      }
+
+      iterator & operator++() {
+         ++mapit;
+         return *this;
+      }
+
+      iterator operator++(int) {
+         iterator copy(*this);
+         operator++();
+         return copy;
+      }
+
+      bool operator==(const iterator & rhs) {
+         return mapit == rhs.mapit;
+      }
+
+      bool operator!=(const iterator & rhs) {
+         return !(*this == rhs);
+      }
+
+      ValueType operator*() {
+         return *mapit;
+      }
+
+      ValueType *operator->() {
+         return mapit;
+      }
+   };
+
+   iterator begin() const {
+      return iterator(map.begin());
+   }
+
+   iterator end() const {
+      return iterator(map.end());
+   }
+
+};
+
+extern void error(std::string msg);
+
+template <typename ValueType>
+HashSet<ValueType>::HashSet() {
+   /* Empty */
+}
+
+template <typename ValueType>
+HashSet<ValueType>::~HashSet() {
+   /* Empty */
+}
+
+template <typename ValueType>
+int HashSet<ValueType>::size() const {
+   return map.size();
+}
+
+template <typename ValueType>
+bool HashSet<ValueType>::isEmpty() const {
+   return map.isEmpty();
+}
+
+template <typename ValueType>
+void HashSet<ValueType>::add(const ValueType & value) {
+   map.put(value, true);
+}
+
+template <typename ValueType>
+void HashSet<ValueType>::insert(const ValueType & value) {
+   map.put(value, true);
+}
+
+template <typename ValueType>
+void HashSet<ValueType>::remove(const ValueType & value) {
+   map.remove(value);
+}
+
+template <typename ValueType>
+bool HashSet<ValueType>::contains(const ValueType & value) const {
+   return map.containsKey(value);
+}
+
+template <typename ValueType>
+void HashSet<ValueType>::clear() {
+   map.clear();
+}
+
+template <typename ValueType>
+bool HashSet<ValueType>::isSubsetOf(const HashSet & set2) const {
+   iterator it = begin();
+   iterator end = this->end();
+   while (it != end) {
+      if (!set2.map.containsKey(*it)) return false;
+      ++it;
+   }
+   return true;
+}
+
+/*
+ * Implementation notes: set operators
+ * -----------------------------------
+ * The implementations for the set operators use iteration to walk
+ * over the elements in one or both sets.
+ */
+
+template <typename ValueType>
+bool HashSet<ValueType>::operator==(const HashSet & set2) const {
+   return this->isSubsetOf(set2) && set2.isSubsetOf(*this);
+}
+
+template <typename ValueType>
+bool HashSet<ValueType>::operator!=(const HashSet & set2) const {
+   return !(*this == set2);
+}
+
+template <typename ValueType>
+HashSet<ValueType> HashSet<ValueType>::operator+(const HashSet & set2) const {
+   HashSet<ValueType> set = *this;
+   foreach (ValueType value in set2) {
+      set.add(value);
+   }
+   return set;
+}
+
+template <typename ValueType>
+HashSet<ValueType>
+HashSet<ValueType>::operator+(const ValueType & element) const {
+   HashSet<ValueType> set = *this;
+   set.add(element);
+   return set;
+}
+
+template <typename ValueType>
+HashSet<ValueType> HashSet<ValueType>::operator*(const HashSet & set2) const {
+   HashSet<ValueType> set;
+   foreach (ValueType value in *this) {
+      if (set2.map.containsKey(value)) set.add(value);
+   }
+   return set;
+}
+
+template <typename ValueType>
+HashSet<ValueType> HashSet<ValueType>::operator-(const HashSet & set2) const {
+   HashSet<ValueType> set;
+   foreach (ValueType value in *this) {
+      if (!set2.map.containsKey(value)) set.add(value);
+   }
+   return set;
+}
+
+template <typename ValueType>
+HashSet<ValueType>
+HashSet<ValueType>::operator-(const ValueType & element) const {
+   HashSet<ValueType> set = *this;
+   set.remove(element);
+   return set;
+}
+
+template <typename ValueType>
+HashSet<ValueType> & HashSet<ValueType>::operator+=(const HashSet & set2) {
+   foreach (ValueType value in set2) {
+      this->add(value);
+   }
+   return *this;
+}
+
+template <typename ValueType>
+HashSet<ValueType> & HashSet<ValueType>::operator+=(const ValueType & value) {
+   this->add(value);
+   this->removeFlag = false;
+   return *this;
+}
+
+template <typename ValueType>
+HashSet<ValueType> & HashSet<ValueType>::operator*=(const HashSet & set2) {
+   Vector<ValueType> toRemove;
+   foreach (ValueType value in *this) {
+      if (!set2.map.containsKey(value)) toRemove.add(value);
+   }
+   foreach (ValueType value in toRemove) {
+      this->remove(value);
+   }
+   return *this;
+}
+
+template <typename ValueType>
+HashSet<ValueType> & HashSet<ValueType>::operator-=(const HashSet & set2) {
+   Vector<ValueType> toRemove;
+   foreach (ValueType value in *this) {
+      if (set2.map.containsKey(value)) toRemove.add(value);
+   }
+   foreach (ValueType value in toRemove) {
+      this->remove(value);
+   }
+   return *this;
+}
+
+template <typename ValueType>
+HashSet<ValueType> & HashSet<ValueType>::operator-=(const ValueType & value) {
+   this->remove(value);
+   this->removeFlag = true;
+   return *this;
+}
+
+template <typename ValueType>
+ValueType HashSet<ValueType>::first() const {
+   if (isEmpty()) error("first: set is empty");
+   return *begin();
+}
+
+template <typename ValueType>
+std::string HashSet<ValueType>::toString() {
+   ostringstream os;
+   os << *this;
+   return os.str();
+}
+
+template <typename ValueType>
+void HashSet<ValueType>::mapAll(void (*fn)(ValueType)) const {
+   map.mapAll(fn);
+}
+
+template <typename ValueType>
+void HashSet<ValueType>::mapAll(void (*fn)(const ValueType &)) const {
+   map.mapAll(fn);
+}
+
+template <typename ValueType>
+template <typename FunctorType>
+void HashSet<ValueType>::mapAll(FunctorType fn) const {
+   map.mapAll(fn);
+}
+
+template <typename ValueType>
+std::ostream & operator<<(std::ostream & os, const HashSet<ValueType> & set) {
+   os << "{";
+   bool started = false;
+   foreach (ValueType value in set) {
+      if (started) os << ", ";
+      writeGenericValue(os, value, true);
+      started = true;
+   }
+   os << "}";
+   return os;
+}
+
+template <typename ValueType>
+std::istream & operator>>(std::istream & is, HashSet<ValueType> & set) {
+   char ch;
+   is >> ch;
+   if (ch != '{') error("operator >>: Missing {");
+   set.clear();
+   is >> ch;
+   if (ch != '}') {
+      is.unget();
+      while (true) {
+         ValueType value;
+         readGenericValue(is, value);
+         set += value;
+         is >> ch;
+         if (ch == '}') break;
+         if (ch != ',') {
+            error(std::string("operator >>: Unexpected character ") + ch);
+         }
+      }
+   }
+   return is;
+}
+
+// hashing functions for hash sets;  defined in hashmap.cpp
+int hashCode(const HashSet<std::string>& s);
+int hashCode(const HashSet<int>& s);
+int hashCode(const HashSet<char>& s);
+int hashCode(const HashSet<long>& s);
+int hashCode(const HashSet<double>& s);
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/lexicon.cpp b/labb8/lib/StanfordCPPLib/lexicon.cpp
new file mode 100755
index 0000000..140bef2
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/lexicon.cpp
@@ -0,0 +1,316 @@
+/*
+ * File: lexicon.cpp
+ * -----------------
+ * A lexicon is a word list. This lexicon is backed by two separate data
+ * structures for storing the words in the list:
+ *
+ * 1) a DAWG (directed acyclic word graph)
+ * 2) a Set<string> of other words.
+ *
+ * Typically the DAWG is used for a large list read from a file in binary
+ * format.  The STL set is for words added piecemeal at runtime.
+ *
+ * The DAWG idea comes from an article by Appel & Jacobson, CACM May 1988.
+ * This lexicon implementation only has the code to load/search the DAWG.
+ * The DAWG builder code is quite a bit more intricate, see me (Julie)
+ * if you need it.
+ */
+
+#include <fstream>
+#include <string>
+#include <cstring>
+#include <algorithm>
+#include <cstdlib>
+#include <iostream>
+#include <stdint.h>
+#include "error.h"
+#include "lexicon.h"
+#include "strlib.h"
+using namespace std;
+
+static void toLowerCaseInPlace(string & str);
+
+/*
+ * The DAWG is stored as an array of edges. Each edge is represented by
+ * one 32-bit struct.  The 5 "letter" bits indicate the character on this
+ * transition (expressed as integer from 1 to 26), the  "accept" bit indicates
+ * if you accept after appending that char (current path forms word), and the
+ * "lastEdge" bit marks this as the last edge in a sequence of childeren.
+ * The bulk of the bits (24) are used for the index within the edge array for
+ * the children of this node. The children are laid out contiguously in
+ * alphabetical order.  Since we read edges as binary bits from a file in
+ * a big-endian format, we have to swap the struct order for little-endian
+ * machines.
+ */
+
+Lexicon::Lexicon() {
+   edges = start = NULL;
+   numEdges = numDawgWords = 0;
+}
+
+Lexicon::Lexicon(string filename) {
+   edges = start = NULL;
+   numEdges = numDawgWords = 0;
+   addWordsFromFile(filename);
+}
+
+Lexicon::~Lexicon() {
+   if (edges) delete[] edges;
+}
+
+/*
+ * Swaps a 4-byte long from big to little endian byte order
+ */
+
+static uint32_t my_ntohl(uint32_t arg) {
+   uint32_t result = ((arg & 0xff000000) >> 24) |
+                     ((arg & 0x00ff0000) >> 8) |
+                     ((arg & 0x0000ff00) << 8) |
+                     ((arg & 0x000000ff) << 24);
+   return result;
+}
+
+/*
+ * Implementation notes: readBinaryFile
+ * ------------------------------------
+ * The binary lexicon file format must follow this pattern:
+ * DAWG:<startnode index>:<num bytes>:<num bytes block of edge data>
+ */
+
+void Lexicon::readBinaryFile(string filename) {
+   long startIndex, numBytes;
+   char firstFour[4], expected[] = "DAWG";
+   ifstream istr(filename.c_str(), IOS_IN | IOS_BINARY);
+   if (false) my_ntohl(0);
+   if (istr.fail()) {
+      error("Couldn't open lexicon file " + filename);
+   }
+   istr.read(firstFour, 4);
+   istr.get();
+   istr >> startIndex;
+   istr.get();
+   istr >> numBytes;
+   istr.get();
+   if (istr.fail() || strncmp(firstFour, expected, 4) != 0
+                   || startIndex < 0 || numBytes < 0) {
+      error("Improperly formed lexicon file " + filename);
+   }
+   numEdges = numBytes/sizeof(Edge);
+   edges = new Edge[numEdges];
+   start = &edges[startIndex];
+   istr.read((char *)edges, numBytes);
+   if (istr.fail() && !istr.eof()) {
+      error("Improperly formed lexicon file " + filename);
+   }
+
+#if defined(BYTE_ORDER) && BYTE_ORDER == LITTLE_ENDIAN
+   uint32_t *cur = (uint32_t *) edges;
+   for (int i = 0; i < numEdges; i++, cur++) {
+      *cur = my_ntohl(*cur);
+   }
+#endif
+
+   istr.close();
+   numDawgWords = countDawgWords(start);
+}
+
+int Lexicon::countDawgWords(Edge *ep) const {
+   int count = 0;
+   while (true) {
+      if (ep->accept) count++;
+      if (ep->children != 0) {
+         count += countDawgWords(&edges[ep->children]);
+      }
+      if (ep->lastEdge) break;
+      ep++;
+   }
+   return count;
+}
+
+/*
+ * Check for DAWG in first 4 to identify as special binary format,
+ * otherwise assume ASCII, one word per line
+ */
+
+void Lexicon::addWordsFromFile(string filename) {
+   char firstFour[4], expected[] = "DAWG";
+   ifstream istr(filename.c_str());
+   if (istr.fail()) {
+      error("Couldn't open lexicon file " + filename);
+   }
+   istr.read(firstFour, 4);
+   if (strncmp(firstFour, expected, 4) == 0) {
+      if (otherWords.size() != 0) {
+         error("Binary files require an empty lexicon");
+      }
+      readBinaryFile(filename);
+      return;
+   }
+   istr.seekg(0);
+   string line;
+   while (getline(istr, line)) {
+      add(line);
+   }
+   istr.close();
+}
+
+int Lexicon::size() const {
+   return numDawgWords + otherWords.size();
+}
+
+bool Lexicon::isEmpty() const {
+   return size() == 0;
+}
+
+void Lexicon::clear() {
+   if (edges) delete[] edges;
+   edges = start = NULL;
+   numEdges = numDawgWords = 0;
+   otherWords.clear();
+}
+
+/*
+ * Implementation notes: findEdgeForChar
+ * -------------------------------------
+ * Iterate over sequence of children to find one that
+ * matches the given char.  Returns NULL if we get to
+ * last child without finding a match (thus no such
+ * child edge exists).
+ */
+
+Lexicon::Edge *Lexicon::findEdgeForChar(Edge *children, char ch) const {
+   Edge *curEdge = children;
+   while (true) {
+      if (curEdge->letter == charToOrd(ch)) return curEdge;
+      if (curEdge->lastEdge) return NULL;
+      curEdge++;
+   }
+}
+
+/*
+ * Implementation notes: traceToLastEdge
+ * -------------------------------------
+ * Given a string, trace out path through the DAWG edge-by-edge.
+ * If a path exists, return last edge; otherwise return NULL.
+ */
+
+Lexicon::Edge *Lexicon::traceToLastEdge(const string & s) const {
+   if (!start) return NULL;
+   Edge *curEdge = findEdgeForChar(start, s[0]);
+   int len = (int) s.length();
+   for (int i = 1; i < len; i++) {
+      if (!curEdge || !curEdge->children) return NULL;
+      curEdge = findEdgeForChar(&edges[curEdge->children], s[i]);
+   }
+   return curEdge;
+}
+
+bool Lexicon::containsPrefix(string prefix) const {
+   if (prefix.empty()) return true;
+   toLowerCaseInPlace(prefix);
+   if (traceToLastEdge(prefix)) return true;
+   foreach (string word in otherWords) {
+      if (startsWith(word, prefix)) return true;
+      if (prefix < word) return false;
+   }
+   return false;
+}
+
+bool Lexicon::contains(string word) const {
+   toLowerCaseInPlace(word);
+   Edge *lastEdge = traceToLastEdge(word);
+   if (lastEdge && lastEdge->accept) return true;
+   return otherWords.contains(word);
+}
+
+void Lexicon::add(string word) {
+   toLowerCaseInPlace(word);
+   if (!contains(word)) {
+      otherWords.add(word);
+   }
+}
+
+Lexicon::Lexicon(const Lexicon & src) {
+   deepCopy(src);
+}
+
+Lexicon & Lexicon::operator=(const Lexicon & src) {
+   if (this != &src) {
+      if (edges != NULL) delete[] edges;
+      deepCopy(src);
+   }
+   return *this;
+}
+
+void Lexicon::deepCopy(const Lexicon & src) {
+   if (src.edges == NULL) {
+      edges = NULL;
+      start = NULL;
+   } else {
+      numEdges = src.numEdges;
+      edges = new Edge[src.numEdges];
+      memcpy(edges, src.edges, sizeof(Edge)*src.numEdges);
+      start = edges + (src.start - src.edges);
+   }
+   numDawgWords = src.numDawgWords;
+   otherWords = src.otherWords;
+}
+
+void Lexicon::mapAll(void (*fn)(string)) const {
+   foreach (string word in *this) {
+      fn(word);
+   }
+}
+
+void Lexicon::mapAll(void (*fn)(const string &)) const {
+   foreach (string word in *this) {
+      fn(word);
+   }
+}
+
+void Lexicon::iterator::advanceToNextWordInSet() {
+   if (setIterator == setEnd) {
+      currentSetWord = "";
+   } else {
+      currentSetWord = *setIterator;
+      ++setIterator;
+   }
+}
+
+void Lexicon::iterator::advanceToNextWordInDawg() {
+   if (edgePtr == NULL) {
+      edgePtr = lp->start;
+   } else {
+      advanceToNextEdge();
+   }
+   while (edgePtr != NULL && !edgePtr->accept) {
+      advanceToNextEdge();
+   }
+}
+
+void Lexicon::iterator::advanceToNextEdge() {
+   Edge *ep = edgePtr;
+   if (ep->children == 0) {
+      while (ep != NULL && ep->lastEdge) {
+         if (stack.isEmpty()) {
+            edgePtr = NULL;
+            return;
+         } else {
+            ep = stack.pop();
+            currentDawgPrefix.resize(currentDawgPrefix.length() - 1);
+         }
+      }
+      edgePtr = ep + 1;
+   } else {
+      stack.push(ep);
+      currentDawgPrefix.push_back(lp->ordToChar(ep->letter));
+      edgePtr = &lp->edges[ep->children];
+   }
+};
+
+static void toLowerCaseInPlace(string & str) {
+   int nChars = str.length();
+   for (int i = 0; i < nChars; i++) {
+      str[i] = tolower(str[i]);
+   }
+}
diff --git a/labb8/lib/StanfordCPPLib/lexicon.h b/labb8/lib/StanfordCPPLib/lexicon.h
new file mode 100755
index 0000000..fea4726
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/lexicon.h
@@ -0,0 +1,366 @@
+/*
+ * File: lexicon.h
+ * ---------------
+ * This file exports the <code>Lexicon</code> class, which is a
+ * compact structure for storing a list of words.
+ */
+
+#ifndef _lexicon_h
+#define _lexicon_h
+
+#include <string>
+#include "foreach.h"
+#include "set.h"
+#include "stack.h"
+
+/*
+ * Class: Lexicon
+ * --------------
+ * This class is used to represent a <b><i>lexicon,</i></b> or word list.
+ * The main difference between a lexicon and a dictionary is that
+ * a lexicon does not provide any mechanism for storing definitions;
+ * the lexicon contains only words, with no associated information.
+ * It is therefore similar to a set of strings, but with a more
+ * space-efficient internal representation.  The <code>Lexicon</code>
+ * class supports efficient lookup operations for words and prefixes.
+ *
+ * <p>As an example of the use of the <code>Lexicon</code> class, the
+ * following program lists all the two-letter words in the lexicon
+ * stored in <code>EnglishWords.dat</code>:
+ *
+ *<pre>
+ *    int main() {
+ *       Lexicon english("EnglishWords.dat");
+ *       foreach (string word in english) {
+ *          if (word.length() == 2) {
+ *             cout << word << endl;
+ *          }
+ *       }
+ *       return 0;
+ *    }
+ *</pre>
+ */
+
+#include <cctype>
+
+class Lexicon {
+
+public:
+
+/*
+ * Constructor: Lexicon
+ * Usage: Lexicon lex;
+ *        Lexicon lex(filename);
+ * -----------------------------
+ * Initializes a new lexicon.  The default constructor creates an empty
+ * lexicon.  The second form reads in the contents of the lexicon from
+ * the specified data file.  The data file must be in one of two formats:
+ * (1) a space-efficient precompiled binary format or (2) a text file
+ * containing one word per line.  The Stanford library distribution
+ * includes a binary lexicon file named <code>English.dat</code>
+ * containing a list of words in English.  The standard code pattern
+ * to initialize that lexicon looks like this:
+ *
+ *<pre>
+ *    Lexicon english("English.dat");
+ *</pre>
+ */
+
+   Lexicon();
+   Lexicon(std::string filename);
+
+/*
+ * Destructor: ~Lexicon
+ * --------------------
+ * The destructor deallocates any storage associated with the lexicon.
+ */
+
+   virtual ~Lexicon();
+
+/*
+ * Method: size
+ * Usage: int n = lex.size();
+ * --------------------------
+ * Returns the number of words contained in the lexicon.
+ */
+
+   int size() const;
+
+/*
+ * Method: isEmpty
+ * Usage: if (lex.isEmpty()) ...
+ * -----------------------------
+ * Returns <code>true</code> if the lexicon contains no words.
+ */
+
+   bool isEmpty() const;
+
+/*
+ * Method: clear
+ * Usage: lex.clear();
+ * -------------------
+ * Removes all words from the lexicon.
+ */
+
+   void clear();
+
+/*
+ * Method: add
+ * Usage: lex.add(word);
+ * ---------------------
+ * Adds the specified word to the lexicon.
+ */
+
+   void add(std::string word);
+
+/*
+ * Method: addWordsFromFile
+ * Usage: lex.addWordsFromFile(filename);
+ * --------------------------------------
+ * Reads the file and adds all of its words to the lexicon.
+ */
+
+   void addWordsFromFile(std::string filename);
+
+/*
+ * Method: contains
+ * Usage: if (lex.contains(word)) ...
+ * ----------------------------------
+ * Returns <code>true</code> if <code>word</code> is contained in the
+ * lexicon.  In the <code>Lexicon</code> class, the case of letters is
+ * ignored, so "Zoo" is the same as "ZOO" or "zoo".
+ */
+
+   bool contains(std::string word) const;
+
+/*
+ * Method: containsPrefix
+ * Usage: if (lex.containsPrefix(prefix)) ...
+ * ------------------------------------------
+ * Returns true if any words in the lexicon begin with <code>prefix</code>.
+ * Like <code>containsWord</code>, this method ignores the case of letters
+ * so that "MO" is a prefix of "monkey" or "Monday".
+ */
+
+   bool containsPrefix(std::string prefix) const;
+
+/*
+ * Method: mapAll
+ * Usage: lexicon.mapAll(fn);
+ * --------------------------
+ * Calls the specified function on each word in the lexicon.
+ */
+
+   void mapAll(void (*fn)(std::string)) const;
+   void mapAll(void (*fn)(const std::string &)) const;
+
+   template <typename FunctorType>
+   void mapAll(FunctorType fn) const;
+
+/*
+ * Additional Lexicon operations
+ * -----------------------------
+ * In addition to the methods listed in this interface, the Lexicon
+ * class supports the following operations:
+ *
+ *   - Deep copying for the copy constructor and assignment operator
+ *   - Iteration using the range-based for statement and STL iterators
+ *
+ * All iteration is guaranteed to proceed in alphabetical order.  All
+ * words in the lexicon are stored in lowercase.
+ */
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in the file is logically part    */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+private:
+
+#ifdef _WIN32
+#define LITTLE_ENDIAN 1
+#define BYTE_ORDER LITTLE_ENDIAN
+#endif
+
+#pragma pack(1)
+   struct Edge {
+#if defined(BYTE_ORDER) && BYTE_ORDER == LITTLE_ENDIAN
+      unsigned long letter:5;
+      unsigned long lastEdge:1;
+      unsigned long accept:1;
+      unsigned long unused:1;
+      unsigned long children:24;
+#else
+      unsigned long children:24;
+      unsigned long unused:1;
+      unsigned long accept:1;
+      unsigned long lastEdge:1;
+      unsigned long letter:5;
+#endif
+   };
+#pragma pack()
+
+   Edge *edges, *start;
+   int numEdges, numDawgWords;
+   Set<std::string> otherWords;
+
+public:
+
+/*
+ * Deep copying support
+ * --------------------
+ * This copy constructor and operator= are defined to make a
+ * deep copy, making it possible to pass/return lexicons by value
+ * and assign from one lexicon to another.  The entire contents of
+ * the lexicon, including all words, are copied.  Making copies is
+ * generally avoided because of the expense and thus, lexicons are
+ * typically passed by reference.  When a copy is needed, these
+ * operations are supported.
+ */
+
+   Lexicon(const Lexicon & src);
+   Lexicon & operator=(const Lexicon & src);
+
+/*
+ * Iterator support
+ * ----------------
+ * The classes in the StanfordCPPLib collection implement input
+ * iterators so that they work symmetrically with respect to the
+ * corresponding STL classes.
+ */
+
+   class iterator : public std::iterator<std::input_iterator_tag,std::string> {
+   private:
+      const Lexicon *lp;
+      int index;
+      std::string currentDawgPrefix;
+      std::string currentSetWord;
+      std::string tmpWord;
+      Edge *edgePtr;
+      Stack<Edge *> stack;
+      Set<std::string>::iterator setIterator;
+      Set<std::string>::iterator setEnd;
+
+      void advanceToNextWordInDawg();
+      void advanceToNextWordInSet();
+      void advanceToNextEdge();
+
+   public:
+      iterator() {
+         this->lp = NULL;
+      }
+
+      iterator(const Lexicon *lp, bool endFlag) {
+         this->lp = lp;
+         if (endFlag) {
+            index = lp->size();
+         } else {
+            index = 0;
+            edgePtr = NULL;
+            setIterator = lp->otherWords.begin();
+            setEnd = lp->otherWords.end();
+            currentDawgPrefix = "";
+            currentSetWord = "";
+            advanceToNextWordInDawg();
+            advanceToNextWordInSet();
+         }
+      }
+
+      iterator(const iterator & it) {
+         lp = it.lp;
+         index = it.index;
+         currentDawgPrefix = it.currentDawgPrefix;
+         currentSetWord = it.currentSetWord;
+         edgePtr = it.edgePtr;
+         stack = it.stack;
+         setIterator = it.setIterator;
+      }
+
+      iterator & operator++() {
+         if (edgePtr == NULL) {
+            advanceToNextWordInSet();
+         } else {
+            if (currentSetWord == "" || currentDawgPrefix < currentSetWord) {
+               advanceToNextWordInDawg();
+            } else {
+               advanceToNextWordInSet();
+            }
+         }
+         index++;
+         return *this;
+      }
+
+      iterator operator++(int) {
+         iterator copy(*this);
+         operator++();
+         return copy;
+      }
+
+      bool operator==(const iterator & rhs) {
+         return lp == rhs.lp && index == rhs.index;
+      }
+
+      bool operator!=(const iterator & rhs) {
+         return !(*this == rhs);
+      }
+
+      std::string operator*() {
+         if (edgePtr == NULL) return currentSetWord;
+         if (currentSetWord == "" || currentDawgPrefix < currentSetWord) {
+            return currentDawgPrefix + lp->ordToChar(edgePtr->letter);
+         } else {
+            return currentSetWord;
+         }
+      }
+
+      std::string *operator->() {
+         if (edgePtr == NULL) return &currentSetWord;
+         if (currentSetWord == "" || currentDawgPrefix < currentSetWord) {
+            tmpWord = currentDawgPrefix + lp->ordToChar(edgePtr->letter);
+            return &tmpWord;
+         } else {
+            return &currentSetWord;
+         }
+      }
+
+   };
+
+   iterator begin() const {
+      return iterator(this, false);
+   }
+
+   iterator end() const {
+      return iterator(this, true);
+   }
+
+private:
+
+   Edge *findEdgeForChar(Edge *children, char ch) const;
+   Edge *traceToLastEdge(const std::string & s) const;
+   void readBinaryFile(std::string filename);
+   void deepCopy(const Lexicon & src);
+   int countDawgWords(Edge *start) const;
+
+   unsigned int charToOrd(char ch) const {
+      return ((unsigned int)(tolower(ch) - 'a' + 1));
+   }
+
+   char ordToChar(unsigned int ord) const {
+      return ((char)(ord - 1 + 'a'));
+   }
+
+};
+
+template <typename FunctorType>
+void Lexicon::mapAll(FunctorType fn) const {
+   foreach (std::string word in *this) {
+      fn(word);
+   }
+}
+
+// hashing functions for lexicons;  defined in hashmap.cpp
+int hashCode(const Lexicon& l);
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/main.cpp b/labb8/lib/StanfordCPPLib/main.cpp
new file mode 100755
index 0000000..6feb8aa
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/main.cpp
@@ -0,0 +1,108 @@
+/*
+ * File: main.cpp
+ * --------------
+ * This file defines a default version of the Main function that takes
+ * the argc and argv arguments.  This function must be defined in its
+ * own module to ensure that it is loaded only if the client doesn't
+ * supply one.
+ */
+
+#include <exception>
+#include <iostream>
+#include <string>
+
+using namespace std;
+
+int Main(int, char *[]) {
+   extern int Main();
+   return Main();
+}
+
+void __StanfordCPPLib_terminate_handler() {
+   try {
+      throw;   // re-throws the exception that already occurred
+   } catch (const std::exception& ex) {
+      string msg = "\n ***\n";
+      msg += " *** STANFORD C++ LIBRARY \n";
+      msg += " *** An exception occurred during program execution: \n";
+      msg += " *** ";
+      msg += ex.what();
+      msg += "\n ***\n\n";
+      cerr << msg;
+      throw ex;
+   } catch (std::string str) {
+      string msg = "\n ***\n";
+      msg += " *** STANFORD C++ LIBRARY \n";
+      msg += " *** A string exception occurred during program execution: \n";
+      msg += " *** \"";
+      msg += str;
+      msg += "\"\n ***\n";
+      cerr << msg;
+      throw str;
+   } catch (char const* str) {
+      string msg = "\n ***\n";
+      msg += " *** STANFORD C++ LIBRARY \n";
+      msg += " *** A string exception occurred during program execution: \n";
+      msg += " *** \"";
+      msg += str;
+      msg += "\"\n ***\n";
+      cerr << msg;
+      throw str;
+   } catch (int n) {
+      char buf[128];
+      snprintf(buf, 128, "%d", n);
+      string msg = "\n ***\n";
+      msg += " *** STANFORD C++ LIBRARY \n";
+      msg += " *** An int exception occurred during program execution: \n";
+      msg += " *** ";
+      msg += buf;
+      msg += "\n ***\n\n";
+      cerr << msg;
+      throw n;
+   } catch (long l) {
+      char buf[128];
+      snprintf(buf, 128, "%ld", l);
+      string msg = "\n ***\n";
+      msg += " *** STANFORD C++ LIBRARY \n";
+      msg += " *** A long exception occurred during program execution: \n";
+      msg += " *** ";
+      msg += buf;
+      msg += "\n ***\n\n";
+      cerr << msg;
+      throw l;
+   } catch (char c) {
+      string msg = "\n ***\n";
+      msg += " *** STANFORD C++ LIBRARY \n";
+      msg += " *** A char exception occurred during program execution: \n";
+      msg += " *** '";
+      msg += c;
+      msg += "'\n ***\n";
+      cerr << msg;
+      throw c;
+   } catch (bool b) {
+      string msg = "\n ***\n";
+      msg += " *** STANFORD C++ LIBRARY \n";
+      msg += " *** A bool exception occurred during program execution: \n";
+      msg += " *** ";
+      msg += (b ? "true" : "false");
+      msg += "\n ***\n\n";
+      cerr << msg;
+      throw b;
+   } catch (double d) {
+      char buf[128];
+      snprintf(buf, 128, "%lf", d);
+      string msg = "\n ***\n";
+      msg += " *** STANFORD C++ LIBRARY \n";
+      msg += " *** A double exception occurred during program execution: \n";
+      msg += " *** ";
+      msg += buf;
+      msg += "\n ***\n\n";
+      cerr << msg;
+      throw d;
+   }
+   abort();
+}
+
+void __StanfordCPPLib_set_terminate() {
+   set_terminate(__StanfordCPPLib_terminate_handler);
+}
diff --git a/labb8/lib/StanfordCPPLib/map.h b/labb8/lib/StanfordCPPLib/map.h
new file mode 100755
index 0000000..663de03
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/map.h
@@ -0,0 +1,910 @@
+/*
+ * File: map.h
+ * -----------
+ * This file exports the template class <code>Map</code>, which
+ * maintains a collection of <i>key</i>-<i>value</i> pairs.
+ */
+
+#ifndef _map_h
+#define _map_h
+
+#include <cstdlib>
+#include "foreach.h"
+#include "stack.h"
+#include "vector.h"
+
+/*
+ * Class: Map<KeyType,ValueType>
+ * -----------------------------
+ * This class maintains an association between <b><i>keys</i></b> and
+ * <b><i>values</i></b>.  The types used for keys and values are
+ * specified using templates, which makes it possible to use
+ * this structure with any data type.
+ */
+
+template <typename KeyType, typename ValueType>
+class Map {
+
+public:
+
+/*
+ * Constructor: Map
+ * Usage: Map<KeyType,ValueType> map;
+ * ----------------------------------
+ * Initializes a new empty map that associates keys and values of the
+ * specified types.
+ */
+
+   Map();
+
+/*
+ * Destructor: ~Map
+ * ----------------
+ * Frees any heap storage associated with this map.
+ */
+
+   virtual ~Map();
+
+/*
+ * Method: size
+ * Usage: int nEntries = map.size();
+ * ---------------------------------
+ * Returns the number of entries in this map.
+ */
+
+   int size() const;
+
+/*
+ * Method: isEmpty
+ * Usage: if (map.isEmpty()) ...
+ * -----------------------------
+ * Returns <code>true</code> if this map contains no entries.
+ */
+
+   bool isEmpty() const;
+
+/*
+ * Method: put
+ * Usage: map.put(key, value);
+ * ---------------------------
+ * Associates <code>key</code> with <code>value</code> in this map.
+ * Any previous value associated with <code>key</code> is replaced
+ * by the new value.
+ */
+
+   void put(const KeyType & key, const ValueType & value);
+
+/*
+ * Method: get
+ * Usage: ValueType value = map.get(key);
+ * --------------------------------------
+ * Returns the value associated with <code>key</code> in this map.
+ * If <code>key</code> is not found, <code>get</code> returns the
+ * default value for <code>ValueType</code>.
+ */
+
+   ValueType get(const KeyType & key) const;
+
+/*
+ * Method: containsKey
+ * Usage: if (map.containsKey(key)) ...
+ * ------------------------------------
+ * Returns <code>true</code> if there is an entry for <code>key</code>
+ * in this map.
+ */
+
+   bool containsKey(const KeyType & key) const;
+
+/*
+ * Method: remove
+ * Usage: map.remove(key);
+ * -----------------------
+ * Removes any entry for <code>key</code> from this map.
+ */
+
+   void remove(const KeyType & key);
+
+/*
+ * Method: clear
+ * Usage: map.clear();
+ * -------------------
+ * Removes all entries from this map.
+ */
+
+   void clear();
+
+/*
+ * Method: keys
+ * Usage: Vector<KeyType> keys = map.keys();
+ * -------------------------------------------
+ * Returns a collection containing all keys in this map.
+ */
+
+   Vector<KeyType> keys() const;
+
+/*
+ * Method: values
+ * Usage: Vector<ValueType> values = map.values();
+ * -------------------------------------------
+ * Returns a collection containing all values in this map.
+ */
+
+   Vector<ValueType> values() const;
+
+/*
+ * Operator: []
+ * Usage: map[key]
+ * ---------------
+ * Selects the value associated with <code>key</code>.  This syntax
+ * makes it easy to think of a map as an "associative array"
+ * indexed by the key type.  If <code>key</code> is already present
+ * in the map, this function returns a reference to its associated
+ * value.  If key is not present in the map, a new entry is created
+ * whose value is set to the default for the value type.
+ */
+
+   ValueType & operator[](const KeyType & key);
+   ValueType operator[](const KeyType & key) const;
+
+/*
+ * Method: toString
+ * Usage: string str = map.toString();
+ * -----------------------------------
+ * Converts the map to a printable string representation.
+ */
+
+   std::string toString();
+
+/*
+ * Method: mapAll
+ * Usage: map.mapAll(fn);
+ * ----------------------
+ * Iterates through the map entries and calls <code>fn(key, value)</code>
+ * for each one.  The keys are processed in ascending order, as defined
+ * by the comparison function.
+ */
+
+   void mapAll(void (*fn)(KeyType, ValueType)) const;
+   void mapAll(void (*fn)(const KeyType &, const ValueType &)) const;
+   template <typename FunctorType>
+   void mapAll(FunctorType fn) const;
+
+/*
+ * Additional Map operations
+ * -------------------------
+ * In addition to the methods listed in this interface, the Map
+ * class supports the following operations:
+ *
+ *   - Stream I/O using the << and >> operators
+ *   - Deep copying for the copy constructor and assignment operator
+ *   - Iteration using the range-based for statement and STL iterators
+ *
+ * All iteration is guaranteed to proceed in the order established by
+ * the comparison function passed to the constructor, which ordinarily
+ * matches the order of the key type.
+ */
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in the file is logically part    */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+/*
+ * Implementation notes:
+ * ---------------------
+ * The map class is represented using a binary search tree.  The
+ * specific implementation used here is the classic AVL algorithm
+ * developed by Georgii Adel'son-Vel'skii and Evgenii Landis in 1962.
+ */
+
+private:
+
+/* Constant definitions */
+
+   static const int BST_LEFT_HEAVY = -1;
+   static const int BST_IN_BALANCE = 0;
+   static const int BST_RIGHT_HEAVY = +1;
+
+/* Type definition for nodes in the binary search tree */
+
+   struct BSTNode {
+      KeyType key;             /* The key stored in this node         */
+      ValueType value;         /* The corresponding value             */
+      BSTNode *left;           /* Subtree containing all smaller keys */
+      BSTNode *right;          /* Subtree containing all larger keys  */
+      int bf;                  /* AVL balance factor                  */
+   };
+
+/*
+ * Implementation notes: Comparator
+ * --------------------------------
+ * The Comparator class encapsulates a functor that compares two values
+ * of KeyType.  In contrast to the classes in the STL, all of which embed
+ * the comparator in the type, the Map class and its derivatives pass an
+ * optional Comparator value.  While this strategy results in a more
+ * complex implementation, it has the advantage of allowing maps and sets
+ * to carry their own comparators without forcing the client to include
+ * the comparator in the template declaration.  This simplification is
+ * particularly important for the Graph class.
+ *
+ * The allocation is required in the TemplateComparator class because
+ * the type std::binary_function has subclasses but does not define a
+ * virtual destructor.
+ */
+
+   class Comparator {
+   public:
+      virtual ~Comparator() { }
+      virtual bool lessThan(const KeyType & k1, const KeyType & k2) = 0;
+      virtual Comparator *clone() = 0;
+   };
+
+   template <typename CompareType>
+   class TemplateComparator : public Comparator {
+   public:
+      TemplateComparator(CompareType cmp) {
+         this->cmp = new CompareType(cmp);
+      }
+
+      virtual bool lessThan(const KeyType & k1, const KeyType & k2) {
+         return (*cmp)(k1, k2);
+      }
+
+      virtual Comparator *clone() {
+         return new TemplateComparator<CompareType>(*cmp);
+      }
+
+   private:
+      CompareType *cmp;
+   };
+
+   Comparator & getComparator() const {
+      return *cmpp;
+   }
+
+/* Instance variables */
+
+   BSTNode *root;                  /* Pointer to the root of the tree */
+   int nodeCount;                  /* Number of entries in the map    */
+   Comparator *cmpp;               /* Pointer to the comparator       */
+
+   int (*cmpFn)(const KeyType &, const KeyType &);
+
+/* Private methods */
+
+/*
+ * Implementation notes: findNode(t, key)
+ * --------------------------------------
+ * Searches the tree rooted at t to find the specified key, searching
+ * in the left or right subtree, as approriate.  If a matching node
+ * is found, findNode returns a pointer to the value cell in that node.
+ * If no matching node exists in the tree, findNode returns NULL.
+ */
+
+   ValueType *findNode(BSTNode *t, const KeyType & key) const {
+      if (t == NULL)  return NULL;
+      int sign = compareKeys(key, t->key);
+      if (sign == 0) return &t->value;
+      if (sign < 0) {
+         return findNode(t->left, key);
+      } else {
+         return findNode(t->right, key);
+      }
+   }
+
+/*
+ * Implementation notes: addNode(t, key, heightFlag)
+ * -------------------------------------------------
+ * Searches the tree rooted at t to find the specified key, searching
+ * in the left or right subtree, as approriate.  If a matching node
+ * is found, addNode returns a pointer to the value cell in that node,
+ * just like findNode.  If no matching node exists in the tree, addNode
+ * creates a new node with a default value.  The heightFlag reference
+ * parameter returns a bool indicating whether the height of the tree
+ * was changed by this operation.
+ */
+
+   ValueType *addNode(BSTNode * & t, const KeyType & key, bool & heightFlag) {
+      heightFlag = false;
+      if (t == NULL)  {
+         t = new BSTNode();
+         t->key = key;
+         t->value = ValueType();
+         t->bf = BST_IN_BALANCE;
+         t->left = t->right = NULL;
+         heightFlag = true;
+         nodeCount++;
+         return &t->value;
+      }
+      int sign = compareKeys(key, t->key);
+      if (sign == 0) return &t->value;
+      ValueType *vp = NULL;
+      int bfDelta = BST_IN_BALANCE;
+      if (sign < 0) {
+         vp = addNode(t->left, key, heightFlag);
+         if (heightFlag) bfDelta = BST_LEFT_HEAVY;
+      } else {
+         vp = addNode(t->right, key, heightFlag);
+         if (heightFlag) bfDelta = BST_RIGHT_HEAVY;
+      }
+      updateBF(t, bfDelta);
+      heightFlag = (bfDelta != 0 && t->bf != BST_IN_BALANCE);
+      return vp;
+   }
+
+/*
+ * Implementation notes: removeNode(t, key)
+ * ----------------------------------------
+ * Removes the node containing the specified key from the tree rooted
+ * at t.  The return value is true if the height of this subtree
+ * changes.  The removeTargetNode method does the actual deletion.
+ */
+
+   bool removeNode(BSTNode * & t, const KeyType & key) {
+      if (t == NULL) return false;
+      int sign = compareKeys(key, t->key);
+      if (sign == 0) return removeTargetNode(t);
+      int bfDelta = BST_IN_BALANCE;
+      if (sign < 0) {
+         if (removeNode(t->left, key)) bfDelta = BST_RIGHT_HEAVY;
+      } else {
+         if (removeNode(t->right, key)) bfDelta = BST_LEFT_HEAVY;
+      }
+      updateBF(t, bfDelta);
+      return bfDelta != 0 && t->bf == BST_IN_BALANCE;
+   }
+
+/*
+ * Implementation notes: removeTargetNode(t)
+ * -----------------------------------------
+ * Removes the node which is passed by reference as t.  The easy case
+ * occurs when either (or both) of the children is NULL; all you need
+ * to do is replace the node with its non-NULL child, if any.  If both
+ * children are non-NULL, this code finds the rightmost descendent of
+ * the left child; this node may not be a leaf, but will have no right
+ * child.  Its left child replaces it in the tree, after which the
+ * replacement data is moved to the position occupied by the target node.
+ */
+
+   bool removeTargetNode(BSTNode * & t) {
+      BSTNode *toDelete = t;
+      if (t->left == NULL) {
+         t = t->right;
+         delete toDelete;
+         nodeCount--;
+         return true;
+      } else if (t->right == NULL) {
+         t = t->left;
+         delete toDelete;
+         nodeCount--;
+         return true;
+      } else {
+         BSTNode *successor = t->left;
+         while (successor->right != NULL) {
+            successor = successor->right;
+         }
+         t->key = successor->key;
+         t->value = successor->value;
+         if (removeNode(t->left, successor->key)) {
+            updateBF(t, BST_RIGHT_HEAVY);
+            return (t->bf == BST_IN_BALANCE);
+         }
+         return false;
+      }
+   }
+
+/*
+ * Implementation notes: updateBF(t, bfDelta)
+ * ------------------------------------------
+ * Updates the balance factor in the node and rebalances the tree
+ * if necessary.
+ */
+
+   void updateBF(BSTNode * & t, int bfDelta) {
+      t->bf += bfDelta;
+      if (t->bf < BST_LEFT_HEAVY) {
+         fixLeftImbalance(t);
+      } else if (t->bf > BST_RIGHT_HEAVY) {
+         fixRightImbalance(t);
+      }
+   }
+
+/*
+ * Implementation notes: fixLeftImbalance(t)
+ * -----------------------------------------
+ * This function is called when a node has been found that is out
+ * of balance with the longer subtree on the left.  Depending on
+ * the balance factor of the left child, the code performs a
+ * single or double rotation.
+ */
+
+   void fixLeftImbalance(BSTNode * & t) {
+      BSTNode *child = t->left;
+      if (child->bf == BST_RIGHT_HEAVY) {
+         int oldBF = child->right->bf;
+         rotateLeft(t->left);
+         rotateRight(t);
+         t->bf = BST_IN_BALANCE;
+         switch (oldBF) {
+          case BST_LEFT_HEAVY:
+            t->left->bf = BST_IN_BALANCE;
+            t->right->bf = BST_RIGHT_HEAVY;
+            break;
+          case BST_IN_BALANCE:
+            t->left->bf = t->right->bf = BST_IN_BALANCE;
+            break;
+          case BST_RIGHT_HEAVY:
+            t->left->bf = BST_LEFT_HEAVY;
+            t->right->bf = BST_IN_BALANCE;
+            break;
+         }
+      } else if (child->bf == BST_IN_BALANCE) {
+         rotateRight(t);
+         t->bf = BST_RIGHT_HEAVY;
+         t->right->bf = BST_LEFT_HEAVY;
+      } else {
+         rotateRight(t);
+         t->right->bf = t->bf = BST_IN_BALANCE;
+      }
+   }
+
+/*
+ * Implementation notes: rotateLeft(t)
+ * -----------------------------------
+ * This function performs a single left rotation of the tree
+ * that is passed by reference.  The balance factors
+ * are unchanged by this function and must be corrected at a
+ * higher level of the algorithm.
+ */
+
+   void rotateLeft(BSTNode * & t) {
+      BSTNode *child = t->right;
+      t->right = child->left;
+      child->left = t;
+      t = child;
+   }
+
+/*
+ * Implementation notes: fixRightImbalance(t)
+ * ------------------------------------------
+ * This function is called when a node has been found that
+ * is out of balance with the longer subtree on the right.
+ * Depending on the balance factor of the right child, the
+ * code performs a single or double rotation.
+ */
+
+   void fixRightImbalance(BSTNode * & t) {
+      BSTNode *child = t->right;
+      if (child->bf == BST_LEFT_HEAVY) {
+         int oldBF = child->left->bf;
+         rotateRight(t->right);
+         rotateLeft(t);
+         t->bf = BST_IN_BALANCE;
+         switch (oldBF) {
+          case BST_LEFT_HEAVY:
+            t->left->bf = BST_IN_BALANCE;
+            t->right->bf = BST_RIGHT_HEAVY;
+            break;
+          case BST_IN_BALANCE:
+            t->left->bf = t->right->bf = BST_IN_BALANCE;
+            break;
+          case BST_RIGHT_HEAVY:
+            t->left->bf = BST_LEFT_HEAVY;
+            t->right->bf = BST_IN_BALANCE;
+            break;
+         }
+      } else if (child->bf == BST_IN_BALANCE) {
+         rotateLeft(t);
+         t->bf = BST_LEFT_HEAVY;
+         t->left->bf = BST_RIGHT_HEAVY;
+      } else {
+         rotateLeft(t);
+         t->left->bf = t->bf = BST_IN_BALANCE;
+      }
+   }
+
+/*
+ * Implementation notes: rotateRight(t)
+ * ------------------------------------
+ * This function performs a single right rotation of the tree
+ * that is passed by reference.  The balance factors
+ * are unchanged by this function and must be corrected at a
+ * higher level of the algorithm.
+ */
+
+   void rotateRight(BSTNode * & t) {
+
+      BSTNode *child = t->left;
+      t->left = child->right;
+      child->right = t;
+      t = child;
+   }
+
+/*
+ * Implementation notes: deleteTree(t)
+ * -----------------------------------
+ * Deletes all the nodes in the tree.
+ */
+
+   void deleteTree(BSTNode *t) {
+      if (t != NULL) {
+         deleteTree(t->left);
+         deleteTree(t->right);
+         delete t;
+      }
+   }
+
+/*
+ * Implementation notes: mapAll
+ * ----------------------------
+ * Calls fn(key, value) for every key-value pair in the tree.
+ */
+
+   void mapAll(BSTNode *t, void (*fn)(KeyType, ValueType)) const {
+      if (t != NULL) {
+         mapAll(t->left, fn);
+         fn(t->key, t->value);
+         mapAll(t->right, fn);
+      }
+   }
+
+   void mapAll(BSTNode *t,
+               void (*fn)(const KeyType &, const ValueType &)) const {
+      if (t != NULL) {
+         mapAll(t->left, fn);
+         fn(t->key, t->value);
+         mapAll(t->right, fn);
+      }
+   }
+
+   template <typename FunctorType>
+   void mapAll(BSTNode *t, FunctorType fn) const {
+      if (t != NULL) {
+         mapAll(t->left, fn);
+         fn(t->key, t->value);
+         mapAll(t->right, fn);
+      }
+   }
+
+   void deepCopy(const Map & other) {
+      root = copyTree(other.root);
+      nodeCount = other.nodeCount;
+      cmpp = (other.cmpp == NULL) ? NULL : other.cmpp->clone();
+   }
+
+   BSTNode *copyTree(BSTNode * const t) {
+      if (t == NULL) return NULL;
+      BSTNode *np = new BSTNode();
+      np->key = t->key;
+      np->value = t->value;
+      np->bf = t->bf;
+      np->left = copyTree(t->left);
+      np->right = copyTree(t->right);
+      return np;
+   }
+
+public:
+
+/*
+ * Hidden features
+ * ---------------
+ * The remainder of this file consists of the code required to
+ * support deep copying and iteration.  Including these methods in
+ * the public portion of the interface would make that interface more
+ * difficult to understand for the average client.
+ */
+
+/* Extended constructors */
+
+   template <typename CompareType>
+   explicit Map(CompareType cmp) {
+      root = NULL;
+      nodeCount = 0;
+      cmpp = new TemplateComparator<CompareType>(cmp);
+   }
+
+/*
+ * Implementation notes: compareKeys(k1, k2)
+ * -----------------------------------------
+ * Compares the keys k1 and k2 and returns an integer (-1, 0, or +1)
+ * depending on whether k1 < k2, k1 == k2, or k1 > k2, respectively.
+ */
+
+   int compareKeys(const KeyType & k1, const KeyType & k2) const {
+      if (cmpp->lessThan(k1, k2)) return -1;
+      if (cmpp->lessThan(k2, k1)) return +1;
+      return 0;
+   }
+
+/*
+ * Deep copying support
+ * --------------------
+ * This copy constructor and operator= are defined to make a
+ * deep copy, making it possible to pass/return maps by value
+ * and assign from one map to another.
+ */
+
+   Map & operator=(const Map & src) {
+      if (this != &src) {
+         clear();
+         deepCopy(src);
+      }
+      return *this;
+   }
+
+   Map(const Map & src) {
+      deepCopy(src);
+   }
+
+/*
+ * Iterator support
+ * ----------------
+ * The classes in the StanfordCPPLib collection implement input
+ * iterators so that they work symmetrically with respect to the
+ * corresponding STL classes.
+ */
+
+   class iterator : public std::iterator<std::input_iterator_tag,KeyType> {
+
+   private:
+
+      struct NodeMarker {
+         BSTNode *np;
+         bool processed;
+      };
+
+      const Map *mp;               /* Pointer to the map         */
+      int index;                   /* Index of current element   */
+      Stack<NodeMarker> stack;     /* Stack of unprocessed nodes */
+
+      void findLeftmostChild() {
+         BSTNode *np = stack.peek().np;
+         if (np == NULL) return;
+         while (np->left != NULL) {
+            NodeMarker marker = { np->left,  false };
+            stack.push(marker);
+            np = np->left;
+         }
+      }
+
+   public:
+
+      iterator() {
+        /* Empty */
+      }
+
+      iterator(const Map *mp, bool end) {
+         this->mp = mp;
+         if (end || mp->nodeCount == 0) {
+            index = mp->nodeCount;
+         } else {
+            index = 0;
+            NodeMarker marker = { mp->root, false };
+            stack.push(marker);
+            findLeftmostChild();
+         }
+      }
+
+      iterator(const iterator & it) {
+         mp = it.mp;
+         index = it.index;
+         stack = it.stack;
+      }
+
+      iterator & operator++() {
+         NodeMarker marker = stack.pop();
+         BSTNode *np = marker.np;
+         if (np->right == NULL) {
+            while (!stack.isEmpty() && stack.peek().processed) {
+               stack.pop();
+            }
+         } else {
+            marker.processed = true;
+            stack.push(marker);
+            marker.np = np->right;
+            marker.processed = false;
+            stack.push(marker);
+            findLeftmostChild();
+         }
+         index++;
+         return *this;
+      }
+
+      iterator operator++(int) {
+         iterator copy(*this);
+         operator++();
+         return copy;
+      }
+
+      bool operator==(const iterator & rhs) {
+         return mp == rhs.mp && index == rhs.index;
+      }
+
+      bool operator!=(const iterator & rhs) {
+         return !(*this == rhs);
+      }
+
+      KeyType operator*() {
+         return stack.peek().np->key;
+      }
+
+      KeyType *operator->() {
+         return &stack.peek().np->key;
+      }
+
+      friend class Map;
+
+   };
+
+   iterator begin() const {
+      return iterator(this, false);
+   }
+
+   iterator end() const {
+      return iterator(this, true);
+   }
+
+};
+
+template <typename KeyType, typename ValueType>
+Map<KeyType,ValueType>::Map() {
+   root = NULL;
+   nodeCount = 0;
+   cmpp = new TemplateComparator< less<KeyType> >(less<KeyType>());
+}
+
+template <typename KeyType, typename ValueType>
+Map<KeyType,ValueType>::~Map() {
+   if (cmpp != NULL) delete cmpp;
+   deleteTree(root);
+}
+
+template <typename KeyType, typename ValueType>
+int Map<KeyType,ValueType>::size() const {
+   return nodeCount;
+}
+
+template <typename KeyType, typename ValueType>
+bool Map<KeyType,ValueType>::isEmpty() const {
+   return nodeCount == 0;
+}
+
+template <typename KeyType, typename ValueType>
+void Map<KeyType,ValueType>::put(const KeyType & key,
+                                 const ValueType & value) {
+   bool dummy;
+   *addNode(root, key, dummy) = value;
+}
+
+template <typename KeyType, typename ValueType>
+ValueType Map<KeyType,ValueType>::get(const KeyType & key) const {
+   ValueType *vp = findNode(root, key);
+   if (vp == NULL) return ValueType();
+   return *vp;
+}
+
+template <typename KeyType, typename ValueType>
+void Map<KeyType,ValueType>::remove(const KeyType & key) {
+   removeNode(root, key);
+}
+
+template <typename KeyType, typename ValueType>
+void Map<KeyType,ValueType>::clear() {
+   deleteTree(root);
+   root = NULL;
+   nodeCount = 0;
+}
+
+template <typename KeyType, typename ValueType>
+bool Map<KeyType,ValueType>::containsKey(const KeyType & key) const {
+   return findNode(root, key) != NULL;
+}
+
+template <typename KeyType, typename ValueType>
+ValueType & Map<KeyType,ValueType>::operator[](const KeyType & key) {
+   bool dummy;
+   return *addNode(root, key, dummy);
+}
+
+template <typename KeyType, typename ValueType>
+ValueType Map<KeyType,ValueType>::operator[](const KeyType & key) const {
+   return get(key);
+}
+
+template <typename KeyType, typename ValueType>
+void Map<KeyType,ValueType>::mapAll(void (*fn)(KeyType, ValueType)) const {
+   mapAll(root, fn);
+}
+
+template <typename KeyType, typename ValueType>
+void Map<KeyType,ValueType>::mapAll(void (*fn)(const KeyType &,
+                                               const ValueType &)) const {
+   mapAll(root, fn);
+}
+
+template <typename KeyType, typename ValueType>
+template <typename FunctorType>
+void Map<KeyType,ValueType>::mapAll(FunctorType fn) const {
+   mapAll(root, fn);
+}
+
+template <typename KeyType, typename ValueType>
+std::string Map<KeyType,ValueType>::toString() {
+   ostringstream os;
+   os << *this;
+   return os.str();
+}
+
+template <typename KeyType,typename ValueType>
+Vector<KeyType> Map<KeyType,ValueType>::keys() const {
+   Vector<KeyType> keyset;
+   foreach (KeyType key in *this) {
+       keyset.add(key);
+   }
+   return keyset;
+}
+
+template <typename KeyType,typename ValueType>
+Vector<ValueType> Map<KeyType,ValueType>::values() const {
+   Vector<ValueType> values;
+   foreach (KeyType key in *this) {
+       values.add(this->get(key));
+   }
+   return values;
+}
+
+/*
+ * Implementation notes: << and >>
+ * -------------------------------
+ * The insertion and extraction operators use the template facilities in
+ * strlib.h to read and write generic values in a way that treats strings
+ * specially.
+ */
+
+template <typename KeyType, typename ValueType>
+std::ostream & operator<<(std::ostream & os,
+                          const Map<KeyType,ValueType> & map) {
+   os << "{";
+   typename Map<KeyType,ValueType>::iterator begin = map.begin();
+   typename Map<KeyType,ValueType>::iterator end = map.end();
+   typename Map<KeyType,ValueType>::iterator it = begin;
+   while (it != end) {
+      if (it != begin) os << ", ";
+      writeGenericValue(os, *it, false);
+      os << ":";
+      writeGenericValue(os, map[*it], false);
+      ++it;
+   }
+   return os << "}";
+}
+
+template <typename KeyType, typename ValueType>
+std::istream & operator>>(std::istream & is, Map<KeyType,ValueType> & map) {
+   char ch;
+   is >> ch;
+   if (ch != '{') error("operator >>: Missing {");
+   map.clear();
+   is >> ch;
+   if (ch != '}') {
+      is.unget();
+      while (true) {
+         KeyType key;
+         readGenericValue(is, key);
+         is >> ch;
+         if (ch != ':') error("operator >>: Missing colon after key");
+         ValueType value;
+         readGenericValue(is, value);
+         map[key] = value;
+         is >> ch;
+         if (ch == '}') break;
+         if (ch != ',') {
+            error(std::string("operator >>: Unexpected character ") + ch);
+         }
+      }
+   }
+   return is;
+}
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/platform.cpp b/labb8/lib/StanfordCPPLib/platform.cpp
new file mode 100755
index 0000000..d24140e
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/platform.cpp
@@ -0,0 +1,1417 @@
+/*
+ * File: platform.cpp
+ * ------------------
+ * This file implements the platform interface by passing commands to
+ * a Java back end that manages the display.
+ */
+
+#ifdef _WIN32
+#  include <windows.h>
+#  include <tchar.h>
+#  undef MOUSE_EVENT
+#  undef KEY_EVENT
+#  undef MOUSE_MOVED
+#  undef HELP_KEY
+#else
+#  include <sys/types.h>
+#  include <sys/stat.h>
+#  include <dirent.h>
+#  include <errno.h>
+#  include <pwd.h>
+#  include <unistd.h>
+static bool tracePipe;
+static int pin;
+static int pout;
+#endif
+
+#include <algorithm>
+#include <cctype>
+#include <cstdio>
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
+#include "error.h"
+#include "filelib.h"
+#include "gevents.h"
+#include "gtimer.h"
+#include "gtypes.h"
+#include "hashmap.h"
+#include "queue.h"
+#include "platform.h"
+#include "stack.h"
+#include "strlib.h"
+#include "tokenscanner.h"
+#include "vector.h"
+
+using namespace std;
+
+static string getLineConsole();
+static void putConsole(const string & str);
+static void endLineConsole();
+static void echoConsole(const string & str);
+static void fileLogConsole(const string & str);
+static int scanInt(TokenScanner & scanner);
+static double scanDouble(TokenScanner & scanner);
+static GDimension scanDimension(const string & str);
+static GRectangle scanRectangle(const string & str);
+
+class ConsoleStreambuf : public streambuf {
+
+private:
+
+/* Constants */
+
+   static const int BUFFER_SIZE = 1024;
+
+/* Instance variables */
+
+   char inBuffer[BUFFER_SIZE];
+   char outBuffer[BUFFER_SIZE];
+
+public:
+
+   ConsoleStreambuf() {
+      setg(inBuffer, inBuffer, inBuffer);
+      setp(outBuffer, outBuffer + BUFFER_SIZE);
+   }
+
+   ~ConsoleStreambuf() {
+      /* Empty */
+   }
+
+   virtual int underflow() {
+      // Allow long strings at some point
+      string line = getLineConsole();
+      int n = line.length();
+      if (n + 1 >= BUFFER_SIZE) error("String too long");
+      for (int i = 0; i < n; i++) {
+         inBuffer[i] = line[i];
+      }
+      inBuffer[n++] = '\n';
+      inBuffer[n] = '\0';
+      setg(inBuffer, inBuffer, inBuffer + n);
+      return inBuffer[0];
+   }
+
+   virtual int overflow(int ch = EOF) {
+      string line = "";
+      for (char *cp = pbase(); cp < pptr(); cp++) {
+         if (*cp == '\n') {
+            putConsole(line);
+            endLineConsole();
+            line = "";
+         } else {
+            line += *cp;
+         }
+      }
+      if (line != "") {
+         putConsole(line);
+      }
+      setp(outBuffer, outBuffer + BUFFER_SIZE);
+      if (ch != EOF) {
+         outBuffer[0] = ch;
+         pbump(1);
+      }
+      return ch != EOF;
+   }
+
+   virtual int sync() {
+      return overflow();
+   }
+};
+
+/* Private data */
+
+static Queue<GEvent> eventQueue;
+static HashMap<string,GTimerData *> timerTable;
+static HashMap<string,GWindowData *> windowTable;
+static HashMap<string,GObject *> sourceTable;
+static HashMap<string,string> optionTable;
+static string programName;
+static ofstream logfile;
+static streambuf* cin_old_buf;
+static streambuf* cout_old_buf;
+static ConsoleStreambuf* cinout_new_buf;
+
+
+#ifdef _WIN32
+static HANDLE rdFromJBE = NULL;
+static HANDLE wrFromJBE = NULL;
+static HANDLE rdToJBE = NULL;
+static HANDLE wrToJBE = NULL;
+#endif
+
+/* Prototypes */
+
+static void initPipe();
+static void putPipe(string line);
+static string getPipe();
+static string getResult();
+static void getStatus();
+static GEvent parseEvent(string line);
+static GEvent parseMouseEvent(TokenScanner & scanner, EventType type);
+static GEvent parseKeyEvent(TokenScanner & scanner, EventType type);
+static GEvent parseTimerEvent(TokenScanner & scanner, EventType type);
+static GEvent parseWindowEvent(TokenScanner & scanner, EventType type);
+static GEvent parseActionEvent(TokenScanner & scanner, EventType type);
+
+/* Implementation of the Platform class */
+
+Platform::Platform() {
+   /* Empty */
+}
+
+Platform::~Platform() {
+   /* Empty */
+}
+
+/* Unix implementations of filelib.h primitives */
+
+#ifndef _WIN32
+
+bool Platform::fileExists(string filename) {
+   struct stat fileInfo;
+   return stat(filename.c_str(), &fileInfo) == 0;
+}
+
+bool Platform::isFile(string filename) {
+   struct stat fileInfo;
+   if (stat(filename.c_str(), &fileInfo) != 0) return false;
+   return S_ISREG(fileInfo.st_mode) != 0;
+}
+
+bool Platform::isSymbolicLink(string filename) {
+   struct stat fileInfo;
+   if (stat(filename.c_str(), &fileInfo) != 0) return false;
+   return S_ISLNK(fileInfo.st_mode) != 0;
+}
+
+bool Platform::isDirectory(string filename) {
+   struct stat fileInfo;
+   if (stat(filename.c_str(), &fileInfo) != 0) return false;
+   return S_ISDIR(fileInfo.st_mode) != 0;
+}
+
+void Platform::setCurrentDirectory(string path) {
+   if (chdir(path.c_str()) == 0) {
+      string msg = "setCurrentDirectory: ";
+      string err = string(strerror(errno));
+      error(msg + err);
+   }
+}
+
+string Platform::getCurrentDirectory() {
+   char *cwd = getcwd(NULL, 0);
+   if (cwd == NULL) {
+      string msg = "getCurrentDirectory: ";
+      string err = string(strerror(errno));
+      error(msg + err);
+   }
+   string result = string(cwd);
+   free(cwd);
+   return result;
+}
+
+void Platform::createDirectory(string path) {
+   if (endsWith(path, "/")) {
+      path = path.substr(0, path.length() - 2);
+   }
+   if (mkdir(path.c_str(), 0777) != 0) {
+      if (errno == EEXIST && isDirectory(path)) return;
+      string msg = "createDirectory: ";
+      string err = string(strerror(errno));
+      error(msg + err);
+   }
+}
+
+string Platform::getDirectoryPathSeparator() {
+   return "/";
+}
+
+string Platform::getSearchPathSeparator() {
+   return ":";
+}
+
+string Platform::expandPathname(string filename) {
+   if (filename == "") return "";
+   int len = filename.length();
+   if (filename[0] == '~') {
+      int spos = 1;
+      while (spos < len && filename[spos] != '\\' && filename[spos] != '/') {
+         spos++;
+      }
+      char *homedir = NULL;
+      if (spos == 1) {
+         homedir = getenv("HOME");
+         if (homedir == NULL) homedir = getpwuid(getuid())->pw_dir;
+      } else {
+         struct passwd *pw = getpwnam(filename.substr(1, spos - 1).c_str());
+         if (pw == NULL) error("expandPathname: No such user");
+         homedir = pw->pw_dir;
+      }
+      filename = string(homedir) + filename.substr(spos);
+      len = filename.length();
+   }
+   for (int i = 0; i < len; i++) {
+      if (filename[i] == '\\') filename[i] = '/';
+   }
+   return filename;
+}
+
+void Platform::listDirectory(string path, vector<string> & list) {
+   if (path == "") path = ".";
+   DIR *dir = opendir(path.c_str());
+   if (dir == NULL) error(string("listDirectory: Can't open ") + path);
+   list.clear();
+   while (true) {
+      struct dirent *ep = readdir(dir);
+      if (ep == NULL) break;
+      string name = string(ep->d_name);
+      if (name != "." && name != "..") list.push_back(name);
+   }
+   closedir(dir);
+   sort(list.begin(), list.end());
+}
+
+#else
+
+bool Platform::fileExists(string filename) {
+   return GetFileAttributesA(filename.c_str()) != INVALID_FILE_ATTRIBUTES;
+}
+
+bool Platform::isFile(string filename) {
+   DWORD attr = GetFileAttributesA(filename.c_str());
+   return attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_NORMAL);
+}
+
+bool Platform::isSymbolicLink(string filename) {
+   DWORD attr = GetFileAttributesA(filename.c_str());
+   return attr != INVALID_FILE_ATTRIBUTES
+       && (attr & FILE_ATTRIBUTE_REPARSE_POINT);
+}
+
+bool Platform::isDirectory(string filename) {
+   DWORD attr = GetFileAttributesA(filename.c_str());
+   return attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY);
+}
+
+void Platform::setCurrentDirectory(string path) {
+   if (!isDirectory(path) || !SetCurrentDirectoryA(path.c_str())) {
+      error("setCurrentDirectory: Can't change to " + path);
+   }
+}
+
+string Platform::getCurrentDirectory() {
+   char path[MAX_PATH + 1];
+   int n = GetCurrentDirectoryA(MAX_PATH + 1, path);
+   return string(path, n);
+}
+
+void Platform::createDirectory(string path) {
+   if (!CreateDirectoryA(path.c_str(), NULL)) {
+      error("createDirectory: Can't create " + path);
+   }
+}
+
+string Platform::getDirectoryPathSeparator() {
+   return "\\";
+}
+
+string Platform::getSearchPathSeparator() {
+   return ";";
+}
+
+string Platform::expandPathname(string filename) {
+   if (filename == "") return "";
+   int len = filename.length();
+   for (int i = 0; i < len; i++) {
+      if (filename[i] == '/') filename[i] = '\\';
+   }
+   return filename;
+}
+
+void Platform::listDirectory(string path, vector<string> & list) {
+   if (path == "") path = ".";
+   string pattern = path + "\\*.*";
+   WIN32_FIND_DATAA fd;
+   HANDLE h = FindFirstFileA(pattern.c_str(), &fd);
+   if (h == INVALID_HANDLE_VALUE) {
+      error("listDirectory: Can't list directory");
+   }
+   list.clear();
+   while (true) {
+      string name = string(fd.cFileName);
+      if (name != "." && name != "..") list.push_back(name);
+      if (!FindNextFileA(h, &fd)) break;
+   }
+   FindClose(h);
+   sort(list.begin(), list.end());
+}
+
+#endif
+
+string Platform::openFileDialog(string title, string mode, string path) {
+   ostringstream os;
+   os << "File.openFileDialog(";
+   writeQuotedString(os, title);
+   os << ", \"" << mode << "\", \"" << path << "\")";
+   putPipe(os.str());
+   return getResult();
+}
+
+void Platform::createGWindow(const GWindow & gw, double width, double height,
+                             GObject *topCompound) {
+   ostringstream os;
+   os << gw.gwd;
+   string id = os.str();
+   windowTable.put(id, gw.gwd);
+   os.str("");
+   os << "GWindow.create(\"" << id << "\", " << width << ", " << height
+                              << ", \"" << topCompound << "\")";
+   putPipe(os.str());
+   getStatus();
+}
+
+void Platform::deleteGWindow(const GWindow & gw) {
+   ostringstream os;
+   os << gw.gwd;
+   string id = os.str();
+   windowTable.remove(id);
+   os.str("");
+   os << "GWindow.delete(\"" << gw.gwd << "\")";
+   putPipe(os.str());
+}
+
+void Platform::close(const GWindow & gw) {
+   ostringstream os;
+   os << "GWindow.close(\"" << gw.gwd << "\")";
+   putPipe(os.str());
+}
+
+void Platform::requestFocus(const GWindow & gw) {
+   ostringstream os;
+   os << "GWindow.requestFocus(\"" << gw.gwd << "\")";
+   putPipe(os.str());
+}
+
+void Platform::clear(const GWindow & gw) {
+   ostringstream os;
+   os << "GWindow.clear(\"" << gw.gwd << "\")";
+   putPipe(os.str());
+}
+
+void Platform::repaint(const GWindow & gw) {
+   ostringstream os;
+   os << "GWindow.repaint(\"" << gw.gwd << "\")";
+   putPipe(os.str());
+}
+
+void Platform::setVisible(const GWindow&, bool) {
+//   ostringstream os;
+//   os << boolalpha << "GWindow.setVisible(\"" << gw.gwd << "\", "
+//                   << flag << ")";
+//   putPipe(os.str());
+}
+
+void Platform::setWindowTitle(const GWindow & gw, string title) {
+   ostringstream os;
+   os << "GWindow.setTitle(\"" << gw.gwd << "\", ";
+   writeQuotedString(os, title);
+   os << ")";
+   putPipe(os.str());
+}
+
+double Platform::getScreenWidth() {
+   putPipe("GWindow.getScreenWidth()");
+   return stringToReal(getResult());
+}
+
+double Platform::getScreenHeight() {
+   putPipe("GWindow.getScreenHeight()");
+   return stringToReal(getResult());
+}
+
+void Platform::pause(double milliseconds) {
+   ostringstream os;
+   os << "GTimer.pause(" << milliseconds << ")";
+   putPipe(os.str());
+   getStatus();
+}
+
+void Platform::createTimer(const GTimer & timer, double delay) {
+   ostringstream os;
+   os << timer.gtd;
+   string id = os.str();
+   timerTable.put(id, timer.gtd);
+   os.str("");
+   os << "GTimer.create(\"" << id << "\", " << delay << ")";
+   putPipe(os.str());
+}
+
+void Platform::deleteTimer(const GTimer & timer) {
+   ostringstream os;
+   os << timer.gtd;
+   string id = os.str();
+   timerTable.remove(id);
+   os.str("");
+   os << "GTimer.deleteTimer(\"" << id << "\")";
+   putPipe(os.str());
+}
+
+void Platform::startTimer(const GTimer & timer) {
+   ostringstream os;
+   os << "GTimer.startTimer(\"" << timer.gtd << "\")";
+   putPipe(os.str());
+}
+
+void Platform::stopTimer(const GTimer & timer) {
+   ostringstream os;
+   os << "GTimer.stopTimer(\"" << timer.gtd << "\")";
+   putPipe(os.str());
+}
+
+void Platform::createSound(Sound *sound, string filename) {
+   ostringstream os;
+   os << "Sound.create(\"" << sound << "\", ";
+   writeQuotedString(os, filename);
+   os << ")";
+   putPipe(os.str());
+   getStatus();
+}
+
+void Platform::deleteSound(Sound *sound) {
+   ostringstream os;
+   os << "Sound.delete(\"" << sound << "\")";
+   putPipe(os.str());
+}
+
+void Platform::playSound(Sound *sound) {
+   ostringstream os;
+   os << "Sound.play(\"" << sound << "\")";
+   putPipe(os.str());
+}
+
+void Platform::deleteGObject(GObject *gobj) {
+   ostringstream os;
+   os << "GObject.delete(\"" << gobj << "\")";
+   putPipe(os.str());
+}
+
+void Platform::add(GObject *compound, GObject *gobj) {
+   ostringstream os;
+   os << "GCompound.add(\"" << compound << "\", \"" << gobj << "\")";
+   putPipe(os.str());
+}
+
+void Platform::remove(GObject *gobj) {
+   ostringstream os;
+   os << "GObject.remove(\"" << gobj << "\")";
+   putPipe(os.str());
+}
+
+void Platform::setRegionAlignment(const GWindow & gw, string region,
+                                                      string align) {
+   ostringstream os;
+   os << "GWindow.setRegionAlignment(\"" << gw.gwd << "\", \"" << region
+                                         << "\", \"" << align << "\")";
+   putPipe(os.str());
+}
+
+void Platform::addToRegion(const GWindow & gw, GObject *gobj, string region) {
+   ostringstream os;
+   os << "GWindow.addToRegion(\"" << gw.gwd << "\", \"" << gobj << "\", \""
+                                   << region << "\")";
+   putPipe(os.str());
+}
+
+void Platform::removeFromRegion(const GWindow & gw, GObject *gobj,
+                                                    string region) {
+   ostringstream os;
+   os << "GWindow.removeFromRegion(\"" << gw.gwd << "\", \""
+                                       << gobj << "\", \"" << region << "\")";
+   putPipe(os.str());
+}
+
+void Platform::sendForward(GObject *gobj) {
+   ostringstream os;
+   os << "GObject.sendForward(\"" << gobj << "\")";
+   putPipe(os.str());
+}
+
+void Platform::sendToFront(GObject *gobj) {
+   ostringstream os;
+   os << "GObject.sendToFront(\"" << gobj << "\")";
+   putPipe(os.str());
+}
+
+void Platform::sendBackward(GObject *gobj) {
+   ostringstream os;
+   os << "GObject.sendBackward(\"" << gobj << "\")";
+   putPipe(os.str());
+}
+
+void Platform::sendToBack(GObject *gobj) {
+   ostringstream os;
+   os << "GObject.sendToBack(\"" << gobj << "\")";
+   putPipe(os.str());
+}
+
+void Platform::setVisible(GObject *gobj, bool flag) {
+   ostringstream os;
+   os << boolalpha << "GObject.setVisible(\"" << gobj << "\", " << flag << ")";
+   putPipe(os.str());
+}
+
+void Platform::setColor(GObject *gobj, string color) {
+   ostringstream os;
+   os << "GObject.setColor(\"" << gobj << "\", \"" << color << "\")";
+   putPipe(os.str());
+}
+
+void Platform::scale(GObject *gobj, double sx, double sy) {
+   ostringstream os;
+   os << "GObject.scale(\"" << gobj << "\", " << sx << ", " << sy << ")";
+   putPipe(os.str());
+}
+
+void Platform::rotate(GObject *gobj, double theta) {
+   ostringstream os;
+   os << "GObject.rotate(\"" << gobj << "\", " << theta << ")";
+   putPipe(os.str());
+}
+
+// Move this computation into gobjects.cpp
+
+bool Platform::contains(const GObject *gobj, double x, double y) {
+   ostringstream os;
+   os << "GObject.contains(\"" << gobj << "\", " << x << ", " << y << ")";
+   putPipe(os.str());
+   return getResult() == "true";
+}
+
+// Move this computation into gobjects.cpp
+
+GRectangle Platform::getBounds(const GObject *gobj) {
+   ostringstream os;
+   os << "GObject.getBounds(\"" << gobj << "\")";
+   putPipe(os.str());
+   string result = getResult();
+   if (!startsWith(result, "GRectangle(")) error(result);
+   return scanRectangle(result);
+}
+
+void Platform::setLineWidth(GObject *gobj, double lineWidth) {
+   ostringstream os;
+   os << "GObject.setLineWidth(\"" << gobj << "\", " << lineWidth << ")";
+   putPipe(os.str());
+}
+
+void Platform::setLocation(GObject *gobj, double x, double y) {
+   ostringstream os;
+   os << "GObject.setLocation(\"" << gobj << "\", " << x << ", " << y << ")";
+   putPipe(os.str());
+}
+
+void Platform::setSize(GObject *gobj, double width, double height) {
+   ostringstream os;
+   os << "GObject.setSize(\"" << gobj << "\", " << width << ", "
+                                                 << height << ")";
+   putPipe(os.str());
+}
+
+void Platform::setFrameRectangle(GObject *gobj, double x, double y,
+                                                double width, double height) {
+   ostringstream os;
+   os << "GArc.setFrameRectangle(\"" << gobj << "\", "
+                                      << x << ", " << y << ", "
+                                      << width << ", " << height << ")";
+   putPipe(os.str());
+}
+
+void Platform::draw(const GWindow & gw, const GObject *gobj) {
+   ostringstream os;
+   os << "GWindow.draw(\"" << gw.gwd << "\", \"" << gobj << "\")";
+   putPipe(os.str());
+}
+
+void Platform::setFilled(GObject *gobj, bool flag) {
+   ostringstream os;
+   os << boolalpha << "GObject.setFilled(\"" << gobj << "\", " << flag << ")";
+   putPipe(os.str());
+}
+
+void Platform::setFillColor(GObject *gobj, string color) {
+   ostringstream os;
+   os << "GObject.setFillColor(\"" << gobj << "\", \"" << color << "\")";
+   putPipe(os.str());
+}
+
+void Platform::createGRect(GObject *gobj, double width, double height) {
+   ostringstream os;
+   os << "GRect.create(\"" << gobj << "\", " << width << ", "
+                                              << height << ")";
+   putPipe(os.str());
+}
+
+void Platform::createGRoundRect(GObject *gobj, double width, double height,
+                                               double corner) {
+   ostringstream os;
+   os << "GRoundRect.create(\"" << gobj << "\", " << width << ", " << height
+                                         << ", " << corner << ")";
+   putPipe(os.str());
+}
+
+void Platform::createG3DRect(GObject *gobj, double width, double height,
+                                            bool raised) {
+   ostringstream os;
+   os << boolalpha << "G3DRect.create(\"" << gobj << "\", "
+                    << width << ", " << height << ", " << raised << ")";
+   putPipe(os.str());
+}
+
+void Platform::setRaised(GObject *gobj, bool raised) {
+   ostringstream os;
+   os << boolalpha << "G3DRect.setRaised(\"" << gobj << "\", "
+                                             << raised << ")";
+   putPipe(os.str());
+}
+
+void Platform::createGLabel(GObject *gobj, string label) {
+   ostringstream os;
+   // *** BUGBUG: must escape quotation marks in label string (Marty)
+   os << "GLabel.create(\"" << gobj << "\", ";
+   writeQuotedString(os, label);
+   os << ")";
+   putPipe(os.str());
+}
+
+void Platform::createGLine(GObject *gobj, double x1, double y1,
+                                          double x2, double y2) {
+   ostringstream os;
+   os << "GLine.create(\"" << gobj << "\", " << x1 << ", " << y1
+                                    << ", " << x2 << ", " << y2 << ")";
+   putPipe(os.str());
+}
+
+void Platform::setStartPoint(GObject *gobj, double x, double y) {
+   ostringstream os;
+   os << "GLine.setStartPoint(\"" << gobj << "\", " << x << ", " << y << ")";
+   putPipe(os.str());
+}
+
+void Platform::setEndPoint(GObject *gobj, double x, double y) {
+   ostringstream os;
+   os << "GLine.setEndPoint(\"" << gobj << "\", " << x << ", " << y << ")";
+   putPipe(os.str());
+}
+
+void Platform::createGArc(GObject *gobj, double width, double height,
+                                         double start, double sweep) {
+   ostringstream os;
+   os << "GArc.create(\"" << gobj << "\", " << width << ", " << height
+                                   << ", " << start << ", " << sweep << ")";
+   putPipe(os.str());
+}
+
+void Platform::setStartAngle(GObject *gobj, double angle) {
+   ostringstream os;
+   os << "GArc.setStartAngle(\"" << gobj << "\", " << angle << ")";
+   putPipe(os.str());
+}
+
+void Platform::setSweepAngle(GObject *gobj, double angle) {
+   ostringstream os;
+   os << "GArc.setSweepAngle(\"" << gobj << "\", " << angle << ")";
+   putPipe(os.str());
+}
+
+GDimension Platform::createGImage(GObject *gobj, string filename) {
+   ostringstream os;
+   os << "GImage.create(\"" << gobj << "\", \"" << filename << "\")";
+   putPipe(os.str());
+   string result = getResult();
+   if (!startsWith(result, "GDimension(")) error(result);
+   return scanDimension(result);
+}
+
+void Platform::createGPolygon(GObject *gobj) {
+   ostringstream os;
+   os << "GPolygon.create(\"" << gobj << "\")";
+   putPipe(os.str());
+}
+
+void Platform::addVertex(GObject *gobj, double x, double y) {
+   ostringstream os;
+   os << "GPolygon.addVertex(\"" << gobj << "\", " << x << ", " << y << ")";
+   putPipe(os.str());
+}
+
+void Platform::createGOval(GObject *gobj, double width, double height) {
+   ostringstream os;
+   os << "GOval.create(\"" << gobj << "\", " << width << ", "
+                                              << height << ")";
+   putPipe(os.str());
+}
+
+void Platform::setActionCommand(GObject *gobj, string cmd) {
+   ostringstream os;
+   os << "GInteractor.setActionCommand(\"" << gobj << "\", ";
+   writeQuotedString(os, cmd);
+   os << ")";
+   putPipe(os.str());
+}
+
+GDimension Platform::getSize(GObject *gobj) {
+   ostringstream os;
+   os << "GInteractor.getSize(\"" << gobj << "\")";
+   putPipe(os.str());
+   return scanDimension(getResult());
+}
+
+void Platform::createGButton(GObject *gobj, string label) {
+   ostringstream os;
+   os << gobj;
+   sourceTable.put(os.str(), gobj);
+   os.str("");
+   os << "GButton.create(\"" << gobj << "\", ";
+   writeQuotedString(os, label);
+   os << ")";
+   putPipe(os.str());
+}
+
+void Platform::createGCheckBox(GObject *gobj, string label) {
+   ostringstream os;
+   os << gobj;
+   sourceTable.put(os.str(), gobj);
+   os.str("");
+   os << "GCheckBox.create(\"" << gobj << "\", ";
+   writeQuotedString(os, label);
+   os << ")";
+   putPipe(os.str());
+}
+
+bool Platform::isSelected(GObject *gobj) {
+   ostringstream os;
+   os << "GCheckBox.isSelected(\"" << gobj << "\")";
+   putPipe(os.str());
+   return getResult() == "true";
+}
+
+void Platform::setSelected(GObject *gobj, bool state) {
+   ostringstream os;
+   os << boolalpha << "GCheckBox.setSelected(\"" << gobj << "\", "
+                                                  << state << ")";
+   putPipe(os.str());
+}
+
+void Platform::createGSlider(GObject *gobj, int min, int max, int value) {
+   ostringstream os;
+   os << gobj;
+   sourceTable.put(os.str(), gobj);
+   os.str("");
+   os << "GSlider.create(\"" << gobj << "\", " << min << ", " << max
+                                      << ", " << value << ")";
+   putPipe(os.str());
+}
+
+int Platform::getValue(GObject *gobj) {
+   ostringstream os;
+   os << "GSlider.getValue(\"" << gobj << "\")";
+   putPipe(os.str());
+   return stringToInteger(getResult());
+}
+
+void Platform::setValue(GObject *gobj, int value) {
+   ostringstream os;
+   os << "GSlider.setValue(\"" << gobj << "\", " << value << ")";
+   putPipe(os.str());
+}
+
+void Platform::createGTextField(GObject *gobj, int nChars) {
+   ostringstream os;
+   os << gobj;
+   sourceTable.put(os.str(), gobj);
+   os.str("");
+   os << "GTextField.create(\"" << gobj << "\", " << nChars << ")";
+   putPipe(os.str());
+}
+
+string Platform::getText(GObject *gobj) {
+   ostringstream os;
+   os << "GTextField.getText(\"" << gobj << "\")";
+   putPipe(os.str());
+   return getResult();
+}
+
+void Platform::setText(GObject *gobj, string str) {
+   ostringstream os;
+   os << "GTextField.setText(\"" << gobj << "\", ";
+   writeQuotedString(os, str);
+   os << ")";
+   putPipe(os.str());
+}
+
+void Platform::createGChooser(GObject *gobj) {
+   ostringstream os;
+   os << gobj;
+   sourceTable.put(os.str(), gobj);
+   os.str("");
+   os << "GChooser.create(\"" << gobj << "\")";
+   putPipe(os.str());
+}
+
+void Platform::addItem(GObject *gobj, string item) {
+   ostringstream os;
+   os << "GChooser.addItem(\"" << gobj << "\", ";
+   writeQuotedString(os, item);
+   os << ")";
+   putPipe(os.str());
+}
+
+string Platform::getSelectedItem(GObject *gobj) {
+   ostringstream os;
+   os << "GChooser.getSelectedItem(\"" << gobj << "\")";
+   putPipe(os.str());
+   return getResult();
+}
+
+void Platform::setSelectedItem(GObject *gobj, string item) {
+   ostringstream os;
+   os << "GChooser.setSelectedItem(\"" << gobj << "\", ";
+   writeQuotedString(os, item);
+   os << ")";
+   putPipe(os.str());
+}
+
+void Platform::createGCompound(GObject *gobj) {
+   ostringstream os;
+   os << "GCompound.create(\"" << gobj << "\")";
+   putPipe(os.str());
+}
+
+void Platform::setFont(GObject *gobj, string font) {
+   ostringstream os;
+   os << "GLabel.setFont(\"" << gobj << "\", \"" << font << "\")";
+   putPipe(os.str());
+}
+
+void Platform::setLabel(GObject *gobj, string str) {
+   ostringstream os;
+   os << "GLabel.setLabel(\"" << gobj << "\", ";
+   writeQuotedString(os, str);
+   os << ")";
+   putPipe(os.str());
+}
+
+double Platform::getFontAscent(const GObject *gobj) {
+   ostringstream os;
+   os << "GLabel.getFontAscent(\"" << gobj << "\")";
+   putPipe(os.str());
+   return stringToReal(getResult());
+}
+
+double Platform::getFontDescent(const GObject *gobj) {
+   ostringstream os;
+   os << "GLabel.getFontDescent(\"" << gobj << "\")";
+   putPipe(os.str());
+   return stringToReal(getResult());
+}
+
+GDimension Platform::getGLabelSize(const GObject *gobj) {
+   ostringstream os;
+   os << "GLabel.getGLabelSize(\"" << gobj << "\")";
+   putPipe(os.str());
+   return scanDimension(getResult());
+}
+
+GEvent Platform::getNextEvent(int mask) {
+   if (eventQueue.isEmpty()) {
+      putPipe("GEvent.getNextEvent(" + integerToString(mask) + ")");
+      getResult();
+      if (eventQueue.isEmpty()) return GEvent();
+   }
+   return eventQueue.dequeue();
+}
+
+GEvent Platform::waitForEvent(int mask) {
+   while (eventQueue.isEmpty()) {
+      putPipe("GEvent.waitForEvent(" + integerToString(mask) + ")");
+      getResult();
+   }
+   return eventQueue.dequeue();
+}
+
+void Platform::exitGraphics() {
+   putPipe("GWindow.exitGraphics()");
+   exit(0);
+}
+
+Platform *getPlatform() {
+   static Platform gp;
+   return &gp;
+}
+
+#ifdef _WIN32
+
+/* Windows implementation of interface to Java back end */
+
+int startupMain(int argc, char **argv) {
+   extern int Main(int argc, char **argv);
+   programName = getRoot(getTail(argv[0]));
+   initPipe();
+#ifndef PLAIN_TEXT_CONSOLE
+   cin_old_buf = cin.rdbuf();
+   cout_old_buf = cout.rdbuf();
+   cinout_new_buf = new ConsoleStreambuf();
+   cin.rdbuf(cinout_new_buf);
+   cout.rdbuf(cinout_new_buf);
+   ShowWindow(GetConsoleWindow(), SW_HIDE);
+#endif
+   return Main(argc, argv);
+}
+
+static void initPipe() {
+   SECURITY_ATTRIBUTES attr;
+   attr.nLength = sizeof(SECURITY_ATTRIBUTES);
+   attr.bInheritHandle = true;
+   attr.lpSecurityDescriptor = NULL;
+   if (!CreatePipe(&rdFromJBE, &wrFromJBE, &attr, 0)) {
+      error("Can't create fromJBE");
+   }
+   if (!SetHandleInformation(rdFromJBE, HANDLE_FLAG_INHERIT, 0)) {
+      error("SetHandleInformation failed for fromJBE");
+   }
+   if (!CreatePipe(&rdToJBE, &wrToJBE, &attr, 0)) {
+      error("Can't create toJBE");
+   }
+   if (!SetHandleInformation(wrToJBE, HANDLE_FLAG_INHERIT, 0)) {
+      error("SetHandleInformation failed for toJBE");
+   }
+   string cmd = "java -jar spl.jar " + programName;
+   int n = cmd.length();
+   char *cmdLine = new char[n + 1];
+   for (int i = 0; i < n; i++) {
+      cmdLine[i] = cmd[i];
+   }
+   cmdLine[n] = '\0';
+   PROCESS_INFORMATION pInfo;
+   memset(&pInfo, 0, sizeof(PROCESS_INFORMATION));
+   STARTUPINFOA sInfo;
+   memset(&sInfo, 0, sizeof(STARTUPINFOA));
+   sInfo.cb = sizeof(STARTUPINFOA);
+   sInfo.dwFlags = STARTF_USESTDHANDLES;
+   sInfo.hStdInput = rdToJBE;
+   sInfo.hStdOutput = wrFromJBE;
+   sInfo.hStdError = wrFromJBE;
+   int ok = CreateProcessA(NULL, cmdLine, NULL, NULL, true, CREATE_NO_WINDOW,
+                           NULL, NULL, &sInfo, &pInfo);
+   if (!ok) {
+      DWORD err = GetLastError();
+      cerr << endl;
+      cerr << "ERROR: Stanford C++ library was unable to connect" << endl;
+      cerr << "       to its Java back-end to launch 'spl.jar'." << endl;
+      cerr << "       Please check your Java installation and make sure" << endl;
+      cerr << "       that spl.jar is properly attached to your project." << endl;
+      cerr << endl;
+      cerr << err << endl;
+   } else {
+      CloseHandle(pInfo.hProcess);
+      CloseHandle(pInfo.hThread);
+   }
+}
+
+static void putPipe(string line) {
+   DWORD nch;
+   WriteFile(wrToJBE, line.c_str(), line.length(), &nch, NULL);
+   WriteFile(wrToJBE, "\n", 1, &nch, NULL);
+   FlushFileBuffers(wrToJBE);
+}
+
+static string getPipe() {
+   string line = "";
+   DWORD nch;
+   while (true) {
+      char ch;
+      ReadFile(rdFromJBE, &ch, 1, &nch, NULL);
+      if (ch == '\n' || ch == '\r') break;
+      line += ch;
+   }
+
+   // cerr << "getPipe(): \"" << line << "\"" << endl;
+   return line;
+}
+
+#else
+
+/* Linux/Mac implementation of interface to Java back end */
+
+static void scanOptions() {
+   char *home = getenv("HOME");
+   if (home != NULL) {
+      string filename = string() + home + "/.spl";
+      ifstream infile(filename.c_str());
+      if (!infile.fail()) {
+         string line;
+         while (getline(infile, line)) {
+            size_t equals = line.find('=');
+            if (equals != string::npos) {
+               string key = line.substr(0, equals);
+               string value = line.substr(equals + 1);
+               optionTable.put(key, value);
+            }
+         }
+         infile.close();
+      }
+   }
+}
+
+static string getOption(string key) {
+   char *str = getenv(key.c_str());
+   if (str != NULL) return string(str);
+   return optionTable.get(key);
+}
+
+int startupMain(int argc, char **argv) {
+   extern int Main(int argc, char **argv);
+   string arg0 = argv[0];
+   programName = getRoot(getTail(arg0));
+   size_t ax = arg0.find(".app/Contents/");
+   if (ax != string::npos) {
+      while (ax > 0 && arg0[ax] != '/') {
+         ax--;
+      }
+      if (ax > 0) {
+         string cwd = arg0.substr(0, ax);
+         chdir(cwd.c_str());
+      }
+   }
+   char *noConsoleFlag = getenv("NOCONSOLE");
+   if (noConsoleFlag != NULL && startsWith(string(noConsoleFlag), "t")) {
+      return Main(argc, argv);
+   }
+   scanOptions();
+   initPipe();
+#ifndef PLAIN_TEXT_CONSOLE
+   cin_old_buf = cin.rdbuf();
+   cout_old_buf = cout.rdbuf();
+   cinout_new_buf = new ConsoleStreambuf();
+   cin.rdbuf(cinout_new_buf);
+   cout.rdbuf(cinout_new_buf);
+   string font = getOption("CPPFONT");
+   if (font != "") setConsoleFont(font);
+#endif
+   return Main(argc, argv);
+}
+
+static void initPipe() {
+   char *trace = getenv("JBETRACE");
+   logfile.open("/dev/tty");
+   tracePipe = trace != NULL && startsWith(toLowerCase(trace), "t");
+   int toJBE[2], fromJBE[2];
+   pipe(toJBE);
+   pipe(fromJBE);
+   int child = fork();
+   if (child == 0) {
+      dup2(toJBE[0], 0);
+      close(toJBE[0]);
+      close(toJBE[1]);
+      dup2(fromJBE[1], 1);
+      close(fromJBE[0]);
+      close(fromJBE[1]);
+#ifdef __APPLE__
+      string option = "-Xdock:name=" + programName;
+      execlp("java", "java", option.c_str(), "-jar", "spl.jar",
+             programName.c_str(), NULL);
+#else
+      execlp("java", "java", "-jar", "spl.jar", programName.c_str(), NULL);
+#endif
+      cerr << endl;
+      cerr << "ERROR: Stanford C++ library was unable to connect" << endl;
+      cerr << "       to its Java back-end to launch 'spl.jar'." << endl;
+      cerr << "       Please check your Java installation and make sure" << endl;
+      cerr << "       that spl.jar is properly attached to your project." << endl;
+      cerr << endl;
+      throw new ErrorException("Could not exec spl.jar");
+   } else {
+      pin = fromJBE[0];
+      pout = toJBE[1];
+      close(fromJBE[1]);
+      close(toJBE[0]);
+   }
+}
+
+static void putPipe(string line) {
+   write(pout, line.c_str(), line.length());
+   write(pout, "\n", 1);
+   if (tracePipe) logfile << "-> " << line << endl;
+}
+
+static string getPipe() {
+   string line = "";
+   while (true) {
+      char ch;
+      read(pin, &ch, 1);
+      if (ch == '\n') break;
+      line += ch;
+   }
+   if (tracePipe) logfile << "<- " << line << endl;
+   return line;
+}
+
+#endif
+
+static string getResult() {
+   while (true) {
+      string line = getPipe();
+      bool result = startsWith(line, "result:");
+      bool event  = startsWith(line, "event:");
+      bool hasACMException = line.find("acm.util.ErrorException") != string::npos;
+      bool hasException    = line.find("xception") != string::npos;
+
+      // *** added by Marty: if there is a back-end error, display it
+      if (((result || event) && hasACMException) || (!result && !event && hasException)) {
+         cerr << "ERROR emitted from Stanford Java back-end process:"
+              << endl << line << endl;
+         throw new ErrorException(line.substr(result ? 7 : 6));
+      } else if (startsWith(line, "result:")) {
+         return line.substr(7);
+      } else if (startsWith(line, "event:")) {
+         eventQueue.enqueue(parseEvent(line.substr(6)));
+      } else {
+         if (line.find("\tat") == 0) {
+            // part of a Java exception stack trace, so echo it
+            cerr << line << endl;
+         }
+      }
+   }
+}
+
+static void getStatus() {
+   string result = getResult();
+   if (result != "ok") error(result);
+}
+
+static GEvent parseEvent(string line) {
+   TokenScanner scanner(line);
+   scanner.ignoreWhitespace();
+   scanner.scanNumbers();
+   scanner.scanStrings();
+   string name = scanner.nextToken();
+   if (name == "mousePressed") {
+      return parseMouseEvent(scanner, MOUSE_PRESSED);
+   } else if (name == "mouseReleased") {
+      return parseMouseEvent(scanner, MOUSE_RELEASED);
+   } else if (name == "mouseClicked") {
+      return parseMouseEvent(scanner, MOUSE_CLICKED);
+   } else if (name == "mouseMoved") {
+      return parseMouseEvent(scanner, MOUSE_MOVED);
+   } else if (name == "mouseDragged") {
+      return parseMouseEvent(scanner, MOUSE_DRAGGED);
+   } else if (name == "keyPressed") {
+      return parseKeyEvent(scanner, KEY_PRESSED);
+   } else if (name == "keyReleased") {
+      return parseKeyEvent(scanner, KEY_RELEASED);
+   } else if (name == "keyTyped") {
+      return parseKeyEvent(scanner, KEY_TYPED);
+   } else if (name == "actionPerformed") {
+      return parseActionEvent(scanner, ACTION_PERFORMED);
+   } else if (name == "timerTicked") {
+      return parseTimerEvent(scanner, TIMER_TICKED);
+   } else if (name == "windowClosed") {
+      GWindowEvent e = parseWindowEvent(scanner, WINDOW_CLOSED);
+      e.getGWindow().setVisible(false);
+      e.getGWindow().close();
+      return e;
+   } else if (name == "windowResized") {
+      return parseWindowEvent(scanner, WINDOW_RESIZED);
+   } else if (name == "lastWindowClosed") {
+      exit(0);
+   } else if (name == "lastWindowGWindow_closed") {
+      exit(0);
+   } else {
+      /* Ignore for now */
+   }
+   return GEvent();
+}
+
+static GEvent parseMouseEvent(TokenScanner & scanner, EventType type) {
+   scanner.verifyToken("(");
+   string id = scanner.getStringValue(scanner.nextToken());
+   scanner.verifyToken(",");
+   double time = scanDouble(scanner);
+   scanner.verifyToken(",");
+   int modifiers = scanInt(scanner);
+   scanner.verifyToken(",");
+   double x = scanDouble(scanner);
+   scanner.verifyToken(",");
+   double y = scanDouble(scanner);
+   scanner.verifyToken(")");
+   GMouseEvent e(type, GWindow(windowTable.get(id)), x, y);
+   e.setEventTime(time);
+   e.setModifiers(modifiers);
+   return e;
+}
+
+static GEvent parseKeyEvent(TokenScanner & scanner, EventType type) {
+   scanner.verifyToken("(");
+   string id = scanner.getStringValue(scanner.nextToken());
+   scanner.verifyToken(",");
+   double time = scanDouble(scanner);
+   scanner.verifyToken(",");
+   int modifiers = scanInt(scanner);
+   scanner.verifyToken(",");
+   int keyChar = scanInt(scanner);
+   scanner.verifyToken(",");
+   int keyCode = scanInt(scanner);
+   scanner.verifyToken(")");
+   GKeyEvent e(type, GWindow(windowTable.get(id)), char(keyChar), keyCode);
+   e.setEventTime(time);
+   e.setModifiers(modifiers);
+   return e;
+}
+
+static GEvent parseTimerEvent(TokenScanner & scanner, EventType type) {
+   scanner.verifyToken("(");
+   string id = scanner.getStringValue(scanner.nextToken());
+   scanner.verifyToken(",");
+   double time = scanDouble(scanner);
+   scanner.verifyToken(")");
+   GTimerEvent e(type, GTimer(timerTable.get(id)));
+   e.setEventTime(time);
+   return e;
+}
+
+static GEvent parseWindowEvent(TokenScanner & scanner, EventType type) {
+   scanner.verifyToken("(");
+   string id = scanner.getStringValue(scanner.nextToken());
+   scanner.verifyToken(",");
+   double time = scanDouble(scanner);
+   scanner.verifyToken(")");
+   GWindowEvent e(type, GWindow(windowTable.get(id)));
+   e.setEventTime(time);
+   return e;
+}
+
+static GEvent parseActionEvent(TokenScanner & scanner, EventType type) {
+   scanner.verifyToken("(");
+   string id = scanner.getStringValue(scanner.nextToken());
+   scanner.verifyToken(",");
+   string action = scanner.getStringValue(scanner.nextToken());
+   scanner.verifyToken(",");
+   double time = scanDouble(scanner);
+   scanner.verifyToken(")");
+   GActionEvent e(type, sourceTable.get(id), action);
+   e.setEventTime(time);
+   return e;
+}
+
+/* Console code */
+
+void Platform::clearConsole() {
+   putPipe("JBEConsole.clear()");
+}
+
+void Platform::setConsoleFont(const string & font) {
+   ostringstream os;
+   os << "JBEConsole.setFont(\"" << font << "\")";
+   putPipe(os.str());
+}
+
+void Platform::setConsoleSize(double width, double height) {
+   ostringstream os;
+   os << "JBEConsole.setSize(" << width << ", " << height << ")";
+   putPipe(os.str());
+}
+
+static string getLineConsole() {
+   putPipe("JBEConsole.getLine()");
+   string result = getResult();
+   echoConsole(result + "\n");   // wrong for multiple inputs on one line
+   return result;
+}
+
+static void putConsole(const string & str) {
+   ostringstream os;
+   os << "JBEConsole.print(";
+   writeQuotedString(os, str);
+   os << ")";
+   putPipe(os.str());
+   echoConsole(str);
+}
+
+static void echoConsole(const string & str) {
+    if (getConsoleEcho()) {
+       // write to the standard cout console for output copy/pasting
+       cin.rdbuf(cin_old_buf);
+       cout.rdbuf(cout_old_buf);
+       cout << str;
+       cout.flush();
+       cin.rdbuf(cinout_new_buf);
+       cout.rdbuf(cinout_new_buf);
+    }
+    fileLogConsole(str);
+}
+
+static void fileLogConsole(const string & str) {
+    string consoleLogFile = getConsoleLogFile();
+    if (consoleLogFile.length() > 0) {
+        // A bit inefficient; opens/writes/closes the file on each print
+        // statement.  But this enables fine-grained control and changing
+        // the log file in mid-execution with minimal code base change
+        ofstream outfile;
+        outfile.open(consoleLogFile.c_str(), fstream::out | fstream::app);
+        outfile << str;
+        outfile.flush();
+        outfile.close();
+    }
+}
+
+static void endLineConsole() {
+   putPipe("JBEConsole.println()");
+   echoConsole("\n");
+}
+
+static int scanInt(TokenScanner & scanner) {
+   string token = scanner.nextToken();
+   if (token == "-") token += scanner.nextToken();
+   return stringToInteger(token);
+}
+
+static double scanDouble(TokenScanner & scanner) {
+   string token = scanner.nextToken();
+   if (token == "-") token += scanner.nextToken();
+   return stringToReal(token);
+}
+
+static GDimension scanDimension(const string & str) {
+   TokenScanner scanner(str);
+   scanner.scanNumbers();
+   scanner.ignoreWhitespace();
+   scanner.verifyToken("GDimension");
+   scanner.verifyToken("(");
+   double width = scanDouble(scanner);
+   scanner.verifyToken(",");
+   double height = scanDouble(scanner);
+   scanner.verifyToken(")");
+   return GDimension(width, height);
+}
+
+static GRectangle scanRectangle(const string & str) {
+   TokenScanner scanner(str);
+   scanner.scanNumbers();
+   scanner.ignoreWhitespace();
+   scanner.verifyToken("GRectangle");
+   scanner.verifyToken("(");
+   double x = scanDouble(scanner);
+   scanner.verifyToken(",");
+   double y = scanDouble(scanner);
+   scanner.verifyToken(",");
+   double width = scanDouble(scanner);
+   scanner.verifyToken(",");
+   double height = scanDouble(scanner);
+   scanner.verifyToken(")");
+   return GRectangle(x, y, width, height);
+}
diff --git a/labb8/lib/StanfordCPPLib/platform.h b/labb8/lib/StanfordCPPLib/platform.h
new file mode 100755
index 0000000..85f916f
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/platform.h
@@ -0,0 +1,134 @@
+/*
+ * File: platform.h
+ * ----------------
+ * This file defines the <code>Platform</code> class, which encapsulates
+ * the platform-specific parts of the StanfordCPPLib package.  This file is
+ * logically part of the implementation and is not interesting to clients.
+ */
+
+#ifndef _platform_h
+#define _platform_h
+
+#include <string>
+#include <vector>
+#include "gevents.h"
+#include "gwindow.h"
+#include "sound.h"
+
+class Platform {
+private:
+   Platform();
+   friend Platform *getPlatform();
+
+public:
+   virtual ~Platform();
+   void clearConsole();
+   void setConsoleFont(const std::string & font);
+   void setConsoleSize(double width, double height);
+   bool fileExists(std::string filename);
+   bool isFile(std::string filename);
+   bool isSymbolicLink(std::string filename);
+   bool isDirectory(std::string filename);
+   void setCurrentDirectory(std::string path);
+   std::string getCurrentDirectory();
+   void createDirectory(std::string path);
+   std::string getDirectoryPathSeparator();
+   std::string getSearchPathSeparator();
+   std::string expandPathname(std::string filename);
+   void listDirectory(std::string path, vector<std::string> & list);
+   std::string openFileDialog(std::string title, std::string mode,
+                              std::string path);
+   void createGWindow(const GWindow & gw, double width, double height,
+                      GObject *topCompound);
+   void deleteGWindow(const GWindow & gw);
+   void close(const GWindow & gw);
+   void requestFocus(const GWindow & gw);
+   void clear(const GWindow & gw);
+   void repaint(const GWindow & gw);
+   void setVisible(const GWindow & gw, bool flag);
+   void setResizable(const GWindow & gw, bool flag);
+   void setWindowTitle(const GWindow & gw, std::string title);
+   void setRegionAlignment(const GWindow & gw, std::string region,
+                                               std::string align);
+   void addToRegion(const GWindow & gw, GObject *gobj, std::string region);
+   void removeFromRegion(const GWindow & gw, GObject *gobj,
+                                             std::string region);
+   void pause(double milliseconds);
+   double getScreenWidth();
+   double getScreenHeight();
+   GEvent waitForEvent(int mask);
+   GEvent getNextEvent(int mask);
+   void exitGraphics();
+   void createTimer(const GTimer & timer, double delay);
+   void deleteTimer(const GTimer & timer);
+   void startTimer(const GTimer & timer);
+   void stopTimer(const GTimer & timer);
+   void createSound(Sound *sound, std::string filename);
+   void deleteSound(Sound *sound);
+   void playSound(Sound *sound);
+   void createGRect(GObject *gobj, double width, double height);
+   void createGRoundRect(GObject *gobj, double width, double height,
+                                        double corner);
+   void createG3DRect(GObject *gobj, double width, double height, bool raised);
+   void setRaised(GObject *gobj, bool raised);
+   void createGOval(GObject *gobj, double width, double height);
+   void createGArc(GObject *gobj, double width, double height,
+                                  double start, double sweep);
+   void setStartAngle(GObject *gobj, double angle);
+   void setSweepAngle(GObject *gobj, double angle);
+   void createGLine(GObject *gobj, double x1, double y1, double x2, double y2);
+   void setStartPoint(GObject *gobj, double x, double y);
+   void setEndPoint(GObject *gobj, double x, double y);
+   void createGLabel(GObject *gobj, std::string label);
+   GDimension createGImage(GObject *gobj, std::string filename);
+   void createGPolygon(GObject *gobj);
+   void addVertex(GObject *gobj, double x, double y);
+   void setActionCommand(GObject *gobj, std::string cmd);
+   GDimension getSize(GObject *gobj);
+   void createGButton(GObject *gobj, std::string label);
+   void createGCheckBox(GObject *gobj, std::string label);
+   bool isSelected(GObject *gobj);
+   void setSelected(GObject *gobj, bool state);
+   void createGSlider(GObject *gobj, int min, int max, int value);
+   int getValue(GObject *gobj);
+   void setValue(GObject *gobj, int value);
+   void createGTextField(GObject *gobj, int nChars);
+   std::string getText(GObject *gobj);
+   void setText(GObject *gobj, std::string str);
+   void createGChooser(GObject *gobj);
+   void addItem(GObject *gobj, std::string item);
+   std::string getSelectedItem(GObject *gobj);
+   void setSelectedItem(GObject *gobj, std::string item);
+   void createGCompound(GObject *gobj);
+   void deleteGObject(GObject *gobj);
+   void add(GObject *compound, GObject *gobj);
+   void remove(GObject *gobj);
+   void sendForward(GObject *gobj);
+   void sendToFront(GObject *gobj);
+   void sendBackward(GObject *gobj);
+   void sendToBack(GObject *gobj);
+   void setVisible(GObject *gobj, bool flag);
+   void setColor(GObject *gobj, std::string color);
+   void scale(GObject *gobj, double sx, double sy);
+   void rotate(GObject *gobj, double theta);
+   GRectangle getBounds(const GObject *gobj);
+   bool contains(const GObject *gobj, double x, double y);
+   void setLineWidth(GObject *gobj, double lineWidth);
+   void setLocation(GObject *gobj, double x, double y);
+   void setSize(GObject *gobj, double width, double height);
+   void setFrameRectangle(GObject *gobj, double x, double y,
+                                         double width, double height);
+   void draw(const GWindow & gw, const GObject *gobj);
+   void setFilled(GObject *gobj, bool flag);
+   void setFillColor(GObject *gobj, std::string color);
+   void setFont(GObject *gobj, std::string font);
+   void setLabel(GObject *gobj, std::string str);
+   double getFontAscent(const GObject *gobj);
+   double getFontDescent(const GObject *gobj);
+   GDimension getGLabelSize(const GObject *gobj);
+
+};
+
+Platform *getPlatform();
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/point.cpp b/labb8/lib/StanfordCPPLib/point.cpp
new file mode 100755
index 0000000..351e4c8
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/point.cpp
@@ -0,0 +1,44 @@
+/*
+ * File: point.cpp
+ * ---------------
+ * This file implements the point.h interface.
+ */
+
+#include <string>
+#include "point.h"
+#include "strlib.h"
+using namespace std;
+
+Point::Point() {
+   x = 0;
+   y = 0;
+}
+
+Point::Point(int x, int y) {
+   this->x = x;
+   this->y = y;
+}
+
+int Point::getX() const {
+   return x;
+}
+
+int Point::getY() const {
+   return y;
+}
+
+string Point::toString() const {
+   return "(" + integerToString(x) + "," + integerToString(y) + ")";
+}
+
+bool Point::operator==(const Point & p2) const {
+   return (x == p2.x) && (y == p2.y);
+}
+
+bool Point::operator!=(const Point & p2) const {
+   return (x != p2.x) || (y != p2.y);
+}
+
+ostream & operator<<(ostream & os, const Point & pt) {
+   return os << pt.toString();
+}
diff --git a/labb8/lib/StanfordCPPLib/point.h b/labb8/lib/StanfordCPPLib/point.h
new file mode 100755
index 0000000..e138117
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/point.h
@@ -0,0 +1,113 @@
+/*
+ * File: point.h
+ * -------------
+ * This file exports a class representing an integer-valued <i>x</i>-<i>y</i>
+ * pair.
+ */
+
+#ifndef _point_h
+#define _point_h
+
+#include <string>
+
+/*
+ * Class: Point
+ * ------------
+ * This class represents an <i>x</i>-<i>y</i> coordinate point on a
+ * two-dimensional integer grid.  If you need to work with real-valued points,
+ * you should use the <a href="gtypes.html"><code>gtypes.h</code></a>
+ * interface instead.
+ */
+
+class Point {
+
+public:
+
+/*
+ * Constructor: Point
+ * Usage: Point origin;
+ *        Point pt(x, y);
+ * ----------------------
+ * Creates a <code>Point</code> object with the specified x and y coordinates.
+ * If the coordinates are not supplied, the default constructor sets these
+ * fields to 0.
+ */
+
+   Point();
+   Point(int x, int y);
+
+/*
+ * Method: getX
+ * Usage: int x = pt.getX();
+ * -------------------------
+ * Returns the <i>x</i>-coordinate of the point.
+ */
+
+   int getX() const;
+
+/*
+ * Method: getY
+ * Usage: int y = pt.getY();
+ * -------------------------
+ * Returns the <i>y</i>-coordinate of the point.
+ */
+
+   int getY() const;
+
+/*
+ * Method: toString
+ * Usage: string str = pt.toString();
+ * ----------------------------------
+ * Returns a string representation of the <code>Point</code> in the form
+ * <code>"(x, y)"</code>.
+ */
+
+   std::string toString() const;
+
+/*
+ * Friend operator: ==
+ * Usage: if (p1 == p2) ...
+ * ------------------------
+ * Returns <code>true</code> if <code>p1</code> and <code>p2</code>
+ * are the same point.
+ */
+
+   bool operator==(const Point & p2) const;
+
+/*
+ * Friend operator: !=
+ * Usage: if (p1 != p2) ...
+ * ------------------------
+ * Returns <code>true</code> if <code>p1</code> and <code>p2</code>
+ * are different.
+ */
+
+   bool operator!=(const Point & p2) const;
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in the file is logically part    */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+private:
+
+/* Instance variables */
+
+   int x;                         /* The x-coordinate of the point */
+   int y;                         /* The y-coordinate of the point */
+
+};
+
+/*
+ * Operator: <<
+ * Usage: cout << pt;
+ * ------------------
+ * Overloads the <code>&lt;&lt;</code> operator so that it is able
+ * to display <code>Point</code> values.
+ */
+
+std::ostream & operator<<(std::ostream & os, const Point & pt);
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/pqueue.h b/labb8/lib/StanfordCPPLib/pqueue.h
new file mode 100755
index 0000000..1946797
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/pqueue.h
@@ -0,0 +1,400 @@
+/*
+ * File: pqueue.h
+ * --------------
+ * This file exports the <code>PriorityQueue</code> class, a
+ * collection in which values are processed in priority order.
+ */
+
+#ifndef _pqueue_h
+#define _pqueue_h
+
+#include "vector.h"
+
+/*
+ * Class: PriorityQueue<ValueType>
+ * -------------------------------
+ * This class models a structure called a <b><i>priority&nbsp;queue</i></b>
+ * in which values are processed in order of priority.  As in conventional
+ * English usage, lower priority numbers correspond to higher effective
+ * priorities, so that a priority 1 item takes precedence over a
+ * priority 2 item.
+ */
+
+template <typename ValueType>
+class PriorityQueue {
+
+public:
+
+/*
+ * Constructor: PriorityQueue
+ * Usage: PriorityQueue<ValueType> pq;
+ * -----------------------------------
+ * Initializes a new priority queue, which is initially empty.
+ */
+
+   PriorityQueue();
+
+/*
+ * Destructor: ~PriorityQueue
+ * --------------------------
+ * Frees any heap storage associated with this priority queue.
+ */
+
+   virtual ~PriorityQueue();
+
+/*
+ * Method: size
+ * Usage: int n = pq.size();
+ * -------------------------
+ * Returns the number of values in the priority queue.
+ */
+
+   int size() const;
+
+/*
+ * Method: isEmpty
+ * Usage: if (pq.isEmpty()) ...
+ * ----------------------------
+ * Returns <code>true</code> if the priority queue contains no elements.
+ */
+
+   bool isEmpty() const;
+
+/*
+ * Method: clear
+ * Usage: pq.clear();
+ * ------------------
+ * Removes all elements from the priority queue.
+ */
+
+   void clear();
+
+/*
+ * Method: enqueue
+ * Usage: pq.enqueue(value, priority);
+ * -----------------------------------
+ * Adds <code>value</code> to the queue with the specified priority.
+ * Lower priority numbers correspond to higher priorities, which
+ * means that all priority 1 elements are dequeued before any
+ * priority 2 elements.
+ */
+
+   void enqueue(ValueType value, double priority);
+
+/*
+ * Method: changePriority
+ * Usage: pq.changePriority(value, newPriority);
+ * -----------------------------------
+ * Adjusts <code>value</code> in the queue to now have the specified new priority,
+ * which must be at least as urgent (lower number) than that value's previous
+ * priority in the queue.
+ * Throws an error if the element value is not present in the queue, or if the
+ * new priority passed is not at least as urgent as its current priority.
+ */
+
+void changePriority(ValueType value, double newPriority);
+
+/*
+ * Method: dequeue
+ * Usage: ValueType first = pq.dequeue();
+ * --------------------------------------
+ * Removes and returns the highest priority value.  If multiple
+ * entries in the queue have the same priority, those values are
+ * dequeued in the same order in which they were enqueued.
+ */
+
+   ValueType dequeue();
+
+/*
+ * Method: peek
+ * Usage: ValueType first = pq.peek();
+ * -----------------------------------
+ * Returns the value of highest priority in the queue, without
+ * removing it.
+ */
+
+   ValueType peek() const;
+
+/*
+ * Method: peekPriority
+ * Usage: double priority = pq.peekPriority();
+ * -------------------------------------------
+ * Returns the priority of the first element in the queue, without
+ * removing it.
+ */
+
+   double peekPriority() const;
+
+/*
+ * Method: front
+ * Usage: ValueType first = pq.front();
+ * ------------------------------------
+ * Returns the first value in the queue by reference.
+ */
+
+   ValueType & front();
+
+/*
+ * Method: back
+ * Usage: ValueType last = pq.back();
+ * ----------------------------------
+ * Returns the last value in the queue by reference.
+ */
+
+   ValueType & back();
+
+/*
+ * Method: toString
+ * Usage: string str = pq.toString();
+ * ----------------------------------
+ * Converts the queue to a printable string representation.
+ */
+
+   std::string toString();
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in the file is logically part    */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+/*
+ * Implementation notes: PriorityQueue data structure
+ * --------------------------------------------------
+ * The PriorityQueue class is implemented using a data structure called
+ * a heap.
+ */
+
+private:
+
+/* Type used for each heap entry */
+
+   struct HeapEntry {
+      ValueType value;
+      double priority;
+      long sequence;
+   };
+
+/* Instance variables */
+
+   Vector<HeapEntry> heap;
+   long enqueueCount;
+   int backIndex;
+   int count;
+   int capacity;
+
+/* Private function prototypes */
+
+   void enqueueHeap(ValueType & value, double priority);
+   ValueType dequeueHeap();
+   bool takesPriority(int i1, int i2);
+   void swapHeapEntries(int i1, int i2);
+
+};
+
+extern void error(std::string msg);
+
+template <typename ValueType>
+PriorityQueue<ValueType>::PriorityQueue() {
+   clear();
+}
+
+/*
+ * Implementation notes: ~PriorityQueue destructor
+ * -----------------------------------------------
+ * All of the dynamic memory is allocated in the Vector class,
+ * so no work is required at this level.
+ */
+
+template <typename ValueType>
+PriorityQueue<ValueType>::~PriorityQueue() {
+   /* Empty */
+}
+
+template <typename ValueType>
+int PriorityQueue<ValueType>::size() const {
+   return count;
+}
+
+template <typename ValueType>
+bool PriorityQueue<ValueType>::isEmpty() const {
+   return count == 0;
+}
+
+template <typename ValueType>
+void PriorityQueue<ValueType>::clear() {
+   heap.clear();
+   count = 0;
+}
+
+template <typename ValueType>
+void PriorityQueue<ValueType>::enqueue(ValueType value, double priority) {
+   if (count == heap.size()) heap.add(HeapEntry());
+   int index = count++;
+   heap[index].value = value;
+   heap[index].priority = priority;
+   heap[index].sequence = enqueueCount++;
+   if (index == 0 || takesPriority(backIndex, index)) backIndex = index;
+   while (index > 0) {
+      int parent = (index - 1) / 2;
+      if (takesPriority(parent, index)) break;
+      swapHeapEntries(parent, index);
+      index = parent;
+   }
+}
+
+template <typename ValueType>
+void PriorityQueue<ValueType>::changePriority(ValueType value, double newPriority) {
+    // parts of this implementation are adapted from TrailblazerPQueue.h,
+    // which was written by Keith Schwarz
+
+    if (!(newPriority == newPriority)) {
+        error("PriorityQueue::changePriority(" + genericValueToString(value) + ", "
+              + realToString(newPriority) + "): Attempted to use NaN as a priority.");
+    }
+
+    // find the element in the pqueue; must use a simple iteration over elements
+    for (int i = 0; i < count; i++) {
+        if (heap[i].value == value) {
+            if (heap[i].priority < newPriority) {
+                error("PriorityQueue::changePriority(" + genericValueToString(value) + ", "
+                      + realToString(newPriority)
+                      + "): new priority cannot be less urgent than current priority of "
+                      + realToString(heap[i].priority) + ".");
+            }
+            heap[i].priority = newPriority;
+
+            // after changing the priority, must percolate up to proper level
+            // to maintain heap ordering
+            while (i > 0) {
+                int parent = (i - 1) / 2;
+                if (takesPriority(parent, i)) break;
+                swapHeapEntries(parent, i);
+                i = parent;
+            }
+
+            return;
+        }
+    }
+
+    // if we get here, the element was not ever found
+    error("PriorityQueue::changePriority(" + genericValueToString(value) + ", "
+          + realToString(newPriority) + "): Element value not found.");
+}
+
+/*
+ * Implementation notes: dequeue, peek, peekPriority
+ * -------------------------------------------------
+ * These methods must check for an empty queue and report an error
+ * if there is no first element.
+ */
+
+template <typename ValueType>
+ValueType PriorityQueue<ValueType>::dequeue() {
+   if (count == 0) error("dequeue: Attempting to dequeue an empty queue");
+   count--;
+   bool wasBack = (backIndex == count);
+   ValueType value = heap[0].value;
+   swapHeapEntries(0, count);
+   int index = 0;
+   while (true) {
+      int left = 2 * index + 1;
+      int right = 2 * index + 2;
+      if (left >= count) break;
+      int child = left;
+      if (right < count && takesPriority(right, left)) child = right;
+      if (takesPriority(index, child)) break;
+      swapHeapEntries(index, child);
+      index = child;
+   }
+   if (wasBack) backIndex = index;
+   return value;
+}
+
+template <typename ValueType>
+ValueType PriorityQueue<ValueType>::peek() const {
+   if (count == 0) error("peek: Attempting to peek at an empty queue");
+   return heap.get(0).value;
+}
+
+template <typename ValueType>
+double PriorityQueue<ValueType>::peekPriority() const {
+   if (count == 0) error("peekPriority: Attempting to peek at an empty queue");
+   return heap.get(0).priority;
+}
+
+template <typename ValueType>
+ValueType & PriorityQueue<ValueType>::front() {
+   if (count == 0) error("front: Attempting to read front of an empty queue");
+   return heap.get(0).value;
+}
+
+template <typename ValueType>
+ValueType & PriorityQueue<ValueType>::back() {
+   if (count == 0) error("back: Attempting to read back of an empty queue");
+   return heap.get(backIndex).value;
+}
+
+template <typename ValueType>
+bool PriorityQueue<ValueType>::takesPriority(int i1, int i2) {
+   if (heap[i1].priority < heap[i2].priority) return true;
+   if (heap[i1].priority > heap[i2].priority) return false;
+   return (heap[i1].sequence < heap[i2].sequence);
+}
+
+template <typename ValueType>
+void PriorityQueue<ValueType>::swapHeapEntries(int i1, int i2) {
+   HeapEntry entry = heap[i1];
+   heap[i1] = heap[i2];
+   heap[i2] = entry;
+}
+
+template <typename ValueType>
+std::string PriorityQueue<ValueType>::toString() {
+   ostringstream os;
+   os << *this;
+   return os.str();
+}
+
+template <typename ValueType>
+std::ostream & operator<<(std::ostream & os,
+                          const PriorityQueue<ValueType> & pq) {
+   os << "{";
+   PriorityQueue<ValueType> copy = pq;
+   int len = pq.size();
+   for (int i = 0; i < len; i++) {
+      if (i > 0) os << ", ";
+      os << copy.peekPriority() << ":";
+      writeGenericValue(os, copy.dequeue(), true);
+   }
+   return os << "}";
+}
+
+template <typename ValueType>
+std::istream & operator>>(std::istream & is, PriorityQueue<ValueType> & pq) {
+   char ch;
+   is >> ch;
+   if (ch != '{') error("operator >>: Missing {");
+   pq.clear();
+   is >> ch;
+   if (ch != '}') {
+      is.unget();
+      while (true) {
+         double priority;
+         is >> priority >> ch;
+         if (ch != ':') error("operator >>: Missing colon after priority");
+         ValueType value;
+         readGenericValue(is, value);
+         pq.enqueue(value, priority);
+         is >> ch;
+         if (ch == '}') break;
+         if (ch != ',') {
+            error(std::string("operator >>: Unexpected character ") + ch);
+         }
+      }
+   }
+   return is;
+}
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/private/main.h b/labb8/lib/StanfordCPPLib/private/main.h
new file mode 100755
index 0000000..698a97c
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/private/main.h
@@ -0,0 +1,58 @@
+/*
+ * File: main.h
+ * ------------
+ * This file renames the <code>main</code> method in the client's
+ * program to <code>Main</code>, thereby allowing a custom
+ * <code>main</code> method in the libraries to take control
+ * before passing control back to the client program.  The main macro
+ * also defines a function getMainFlags that returns an int whose bits
+ * indicate which of the various interfaces have been loaded by this
+ * definition of main.
+ *
+ * Note: This file can be loaded more than once and must therefore
+ * check to see what has already been defined.
+ */
+
+#ifdef main
+#  undef main
+#  undef CONSOLE_FLAG
+#  undef GRAPHICS_FLAG
+#else
+#  define MAIN_USES_CONSOLE (1<<0)
+#  define MAIN_USES_GRAPHICS (1<<1)
+#endif
+
+#ifdef _console_h
+#  define CONSOLE_FLAG MAIN_USES_CONSOLE
+#else
+#  define CONSOLE_FLAG 0
+#endif
+
+#ifdef _gwindow_h
+#  define GRAPHICS_FLAG MAIN_USES_GRAPHICS
+#else
+#  define GRAPHICS_FLAG 0
+#endif
+
+#if CONSOLE_FLAG | GRAPHICS_FLAG
+
+#define main main(int argc, char **argv) { \
+                extern int _mainFlags; \
+                _mainFlags = GRAPHICS_FLAG + CONSOLE_FLAG; \
+                return startupMain(argc, argv); \
+             } \
+             int Main
+
+extern int startupMain(int argc, char **argv);
+
+#else
+
+#define main main(int argc, char **argv) { \
+                extern int _mainFlags; \
+                _mainFlags = GRAPHICS_FLAG + CONSOLE_FLAG; \
+                return mainWrapper(argc, argv); } \
+             int Main
+
+extern int mainWrapper(int argc, char **argv);
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/private/randompatch.h b/labb8/lib/StanfordCPPLib/private/randompatch.h
new file mode 100755
index 0000000..c7a4b86
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/private/randompatch.h
@@ -0,0 +1,63 @@
+/*
+ * File: private/randompatch.h
+ * ---------------------------
+ * This file patches the implementation of the random number library
+ * to avoid some serious bugs in standard implementations of rand,
+ * particularly on Mac OS X.  It also includes a hack to set the
+ * seed from the RANDOM_SEED environment variable, which makes it
+ * possible to produce repeatable figures.
+ */
+
+/*
+ * Implementation notes: rand, srand
+ * ---------------------------------
+ * To ensure that this package works the same way on all platforms,
+ * this file completely reimplements the rand and srand methods.  The
+ * algorithm is a conventional linear congruential generator with the
+ * parameters used in GNU's gclib.  RAND_MAX for this implementation
+ * is 2147483647 (2^31 - 1).
+ */
+
+#define MULTIPLIER 1103515245
+#define OFFSET 12345
+
+static int _seed = 1;
+
+#undef rand
+#define rand() ((_seed = MULTIPLIER * _seed + OFFSET) & 0x7FFFFFFF)
+
+#undef srand
+#define srand(seed) (_seed = int(seed), _seed = (_seed <= 0) ? 1 : _seed)
+
+#undef RAND_MAX
+#define RAND_MAX 2147483647
+
+/*
+ * Implementation notes: Windows patch
+ * -----------------------------------
+ * On some versions of Windows, the time function is too coarse to use
+ * as a random seed.  On those versions, this definition substitutes the
+ * GetTickCount function.
+ */
+
+#if defined (_MSC_VER) && (_MSC_VER >= 1200)
+#  include <windows.h>
+#  define time(dummy) (GetTickCount())
+#endif
+
+#ifdef __APPLE__
+
+#  include <cstdlib>
+
+   static time_t patchedTime(time_t *) {
+      char *str = getenv("RANDOM_SEED");
+      if (str == NULL) {
+         return time(NULL);
+      } else {
+         return atoi(str);
+      }
+   }
+
+#  define time(dummy) patchedTime(dummy)
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/private/tokenpatch.h b/labb8/lib/StanfordCPPLib/private/tokenpatch.h
new file mode 100755
index 0000000..d4930e5
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/private/tokenpatch.h
@@ -0,0 +1,11 @@
+/*
+ * File: tokenpatch.h
+ * ------------------
+ * This file renames TokenType and WORD to avoid conflict with the
+ * <windows.h> header.
+ */
+
+#ifdef _MSC_VER
+#  define TokenType TokenTypeT
+#  define WORD WORD_TC
+#endif
diff --git a/labb8/lib/StanfordCPPLib/private/tplatform.h b/labb8/lib/StanfordCPPLib/private/tplatform.h
new file mode 100755
index 0000000..6cf4bae
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/private/tplatform.h
@@ -0,0 +1,25 @@
+/*
+ * File: tplatform.h
+ * -----------------
+ * This interface defines the platform-specific methods on threads
+ * and locks.
+ */
+
+/* Methods for threads */
+
+int forkForPlatform(void (*fn)(void *), void *arg);
+void incThreadRefCountForPlatform(int id);
+void decThreadRefCountForPlatform(int id);
+void joinForPlatform(int id);
+int getCurrentThreadForPlatform();
+void yieldForPlatform();
+
+/* Methods for locks */
+
+int initLockForPlatform();
+void incLockRefCountForPlatform(int id);
+void decLockRefCountForPlatform(int id);
+void lockForPlatform(int id);
+void unlockForPlatform(int id);
+void waitForPlatform(int id);
+void signalForPlatform(int id);
diff --git a/labb8/lib/StanfordCPPLib/queue.h b/labb8/lib/StanfordCPPLib/queue.h
new file mode 100755
index 0000000..0d94a2c
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/queue.h
@@ -0,0 +1,372 @@
+/*
+ * File: queue.h
+ * -------------
+ * This file exports the <code>Queue</code> class, a collection
+ * in which values are ordinarily processed in a first-in/first-out
+ * (FIFO) order.
+ */
+
+#ifndef _queue_h
+#define _queue_h
+
+#include "vector.h"
+
+/*
+ * Class: Queue<ValueType>
+ * -----------------------
+ * This class models a linear structure called a <b><i>queue</i></b>
+ * in which values are added at one end and removed from the other.
+ * This discipline gives rise to a first-in/first-out behavior (FIFO)
+ * that is the defining feature of queues.
+ */
+
+template <typename ValueType>
+class Queue {
+
+public:
+
+/*
+ * Constructor: Queue
+ * Usage: Queue<ValueType> queue;
+ * ------------------------------
+ * Initializes a new empty queue.
+ */
+
+   Queue();
+
+/*
+ * Destructor: ~Queue
+ * ------------------
+ * Frees any heap storage associated with this queue.
+ */
+
+   virtual ~Queue();
+
+/*
+ * Method: size
+ * Usage: int n = queue.size();
+ * ----------------------------
+ * Returns the number of values in the queue.
+ */
+
+   int size() const;
+
+/*
+ * Method: isEmpty
+ * Usage: if (queue.isEmpty()) ...
+ * -------------------------------
+ * Returns <code>true</code> if the queue contains no elements.
+ */
+
+   bool isEmpty() const;
+
+/*
+ * Method: clear
+ * Usage: queue.clear();
+ * ---------------------
+ * Removes all elements from the queue.
+ */
+
+   void clear();
+
+/*
+ * Method: enqueue
+ * Usage: queue.enqueue(value);
+ * ----------------------------
+ * Adds <code>value</code> to the end of the queue.
+ */
+
+   void enqueue(ValueType value);
+
+/*
+ * Method: dequeue
+ * Usage: ValueType first = queue.dequeue();
+ * -----------------------------------------
+ * Removes and returns the first item in the queue.
+ */
+
+   ValueType dequeue();
+
+/*
+ * Method: peek
+ * Usage: ValueType first = queue.peek();
+ * --------------------------------------
+ * Returns the first value in the queue, without removing it.  For
+ * compatibility with the STL classes, this method is also exported
+ * under the name <code>front</code>, in which case it returns the
+ * value by reference.
+ */
+
+   ValueType peek() const;
+
+/*
+ * Method: front
+ * Usage: ValueType first = queue.front();
+ * ---------------------------------------
+ * Returns the first value in the queue by reference.
+ */
+
+   ValueType & front();
+
+/*
+ * Method: back
+ * Usage: ValueType last = queue.back();
+ * -------------------------------------
+ * Returns the last value in the queue by reference.
+ */
+
+   ValueType & back();
+
+/*
+ * Method: toString
+ * Usage: string str = queue.toString();
+ * -------------------------------------
+ * Converts the queue to a printable string representation.
+ */
+
+   std::string toString();
+
+/*
+ * Operator: ==
+ * Usage: queue1 == queue2
+ * -------------------
+ * Returns <code>true</code> if <code>queue1</code> and <code>queue2</code>
+ * contain the same elements.
+ */
+
+   bool operator==(const Queue & queue2) const;
+
+/*
+ * Operator: !=
+ * Usage: queue1 != queue2
+ * -------------------
+ * Returns <code>true</code> if <code>queue1</code> and <code>queue2</code>
+ * do not contain the same elements.
+ */
+
+   bool operator!=(const Queue & queue2) const;
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in the file is logically part    */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+/*
+ * Implementation notes: Queue data structure
+ * ------------------------------------------
+ * The Queue class is implemented using a ring buffer.
+ */
+
+private:
+
+/* Instance variables */
+
+   Vector<ValueType> ringBuffer;
+   int count;
+   int capacity;
+   int head;
+   int tail;
+
+/* Private functions */
+
+   void expandRingBufferCapacity();
+
+};
+
+extern void error(std::string msg);
+
+/*
+ * Implementation notes: Queue data structure
+ * ------------------------------------------
+ * The array-based queue stores the elements in successive index
+ * positions in a vector, just as a stack does.  What makes the
+ * queue structure more complex is the need to avoid shifting
+ * elements as the queue expands and contracts.  In the array
+ * model, this goal is achieved by keeping track of both the
+ * head and tail indices.  The tail index increases by one each
+ * time an element is enqueued, and the head index increases by
+ * one each time an element is dequeued.  Each index therefore
+ * marches toward the end of the allocated vector and will
+ * eventually reach the end.  Rather than allocate new memory,
+ * this implementation lets each index wrap around back to the
+ * beginning as if the ends of the array of elements were joined
+ * to form a circle.  This representation is called a ring buffer.
+ */
+
+const int INITIAL_CAPACITY = 10;
+
+/*
+ * Implementation notes: Queue constructor
+ * ---------------------------------------
+ * The constructor must allocate the array storage for the queue
+ * elements and initialize the fields of the object.
+ */
+
+template <typename ValueType>
+Queue<ValueType>::Queue() {
+   clear();
+}
+
+/*
+ * Implementation notes: ~Queue destructor
+ * ---------------------------------------
+ * All of the dynamic memory is allocated in the Vector class,
+ * so no work is required at this level.
+ */
+
+template <typename ValueType>
+Queue<ValueType>::~Queue() {
+   /* Empty */
+}
+
+template <typename ValueType>
+int Queue<ValueType>::size() const {
+   return count;
+}
+
+template <typename ValueType>
+bool Queue<ValueType>::isEmpty() const {
+   return count == 0;
+}
+
+template <typename ValueType>
+void Queue<ValueType>::clear() {
+   capacity = INITIAL_CAPACITY;
+   ringBuffer = Vector<ValueType>(capacity);
+   head = 0;
+   tail = 0;
+   count = 0;
+}
+
+template <typename ValueType>
+void Queue<ValueType>::enqueue(ValueType value) {
+   if (count >= capacity - 1) expandRingBufferCapacity();
+   ringBuffer[tail] = value;
+   tail = (tail + 1) % capacity;
+   count++;
+}
+
+/*
+ * Implementation notes: dequeue, peek
+ * -----------------------------------
+ * These methods must check for an empty queue and report an error
+ * if there is no first element.
+ */
+
+template <typename ValueType>
+ValueType Queue<ValueType>::dequeue() {
+   if (count == 0) error("dequeue: Attempting to dequeue an empty queue");
+   ValueType result = ringBuffer[head];
+   head = (head + 1) % capacity;
+   count--;
+   return result;
+}
+
+template <typename ValueType>
+ValueType Queue<ValueType>::peek() const {
+   if (count == 0) error("peek: Attempting to peek at an empty queue");
+   return ringBuffer.get(head);
+}
+
+template <typename ValueType>
+ValueType & Queue<ValueType>::front() {
+   if (count == 0) error("front: Attempting to read front of an empty queue");
+   return ringBuffer[head];
+}
+
+template <typename ValueType>
+ValueType & Queue<ValueType>::back() {
+   if (count == 0) error("back: Attempting to read back of an empty queue");
+   return ringBuffer[(tail + capacity - 1) % capacity];
+}
+
+/*
+ * Implementation notes: expandRingBufferCapacity
+ * ----------------------------------------------
+ * This private method doubles the capacity of the ringBuffer vector.
+ * Note that this implementation also shifts all the elements back to
+ * the beginning of the vector.
+ */
+
+template <typename ValueType>
+void Queue<ValueType>::expandRingBufferCapacity() {
+   Vector<ValueType> copy = ringBuffer;
+   ringBuffer = Vector<ValueType>(2 * capacity);
+   for (int i = 0; i < count; i++) {
+      ringBuffer[i] = copy[(head + i) % capacity];
+   }
+   head = 0;
+   tail = count;
+   capacity *= 2;
+}
+
+template <typename ValueType>
+std::string Queue<ValueType>::toString() {
+   ostringstream os;
+   os << *this;
+   return os.str();
+}
+
+template <typename ValueType>
+bool Queue<ValueType>::operator==(const Queue & queue2) const {
+   if (size() != queue2.size()) return false;
+   Queue<ValueType> copy1 = *this;
+   Queue<ValueType> copy2 = queue2;
+   for (int i = 0; i < size(); i++) {
+       if (copy1.dequeue() != copy2.dequeue()) {
+           return false;
+       }
+   }
+   return true;
+}
+
+template <typename ValueType>
+bool Queue<ValueType>::operator!=(const Queue & queue2) const {
+   return !(*this == queue2);
+}
+
+template <typename ValueType>
+std::ostream & operator<<(std::ostream & os, const Queue<ValueType> & queue) {
+   os << "{";
+   Queue<ValueType> copy = queue;
+   int len = queue.size();
+   for (int i = 0; i < len; i++) {
+      if (i > 0) os << ", ";
+      writeGenericValue(os, copy.dequeue(), true);
+   }
+   return os << "}";
+}
+
+template <typename ValueType>
+std::istream & operator>>(std::istream & is, Queue<ValueType> & queue) {
+   char ch;
+   is >> ch;
+   if (ch != '{') error("operator >>: Missing {");
+   queue.clear();
+   is >> ch;
+   if (ch != '}') {
+      is.unget();
+      while (true) {
+         ValueType value;
+         readGenericValue(is, value);
+         queue.enqueue(value);
+         is >> ch;
+         if (ch == '}') break;
+         if (ch != ',') {
+            error(std::string("operator >>: Unexpected character ") + ch);
+         }
+      }
+   }
+   return is;
+}
+
+// hashing functions for queues;  defined in hashmap.cpp
+int hashCode(const Queue<std::string>& q);
+int hashCode(const Queue<int>& q);
+int hashCode(const Queue<char>& q);
+int hashCode(const Queue<long>& q);
+int hashCode(const Queue<double>& q);
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/random.cpp b/labb8/lib/StanfordCPPLib/random.cpp
new file mode 100755
index 0000000..b7ea860
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/random.cpp
@@ -0,0 +1,99 @@
+/*
+ * File: random.cpp
+ * ----------------
+ * This file implements the random.h interface.
+ */
+
+#include <cstdlib>
+#include <cmath>
+#include <ctime>
+#include "random.h"
+#include "private/randompatch.h"
+using namespace std;
+
+/* Private function prototype */
+
+static void initRandomSeed();
+
+/*
+ * Implementation notes: randomInteger
+ * -----------------------------------
+ * The code for randomInteger produces the number in four steps:
+ *
+ * 1. Generate a random real number d in the range [0 .. 1).
+ * 2. Scale the number to the range [0 .. N) where N is the number of values.
+ * 3. Translate the number so that the range starts at the appropriate value.
+ * 4. Convert the result to the next lower integer.
+ *
+ * The implementation is complicated by the fact that both the expression
+ *
+ *     RAND_MAX + 1
+ *
+ * and the expression for the number of values
+ *
+ *     high - low + 1
+ *
+ * can overflow the integer range.  These calculations must therefore be
+ * performed using doubles instead of ints.
+ */
+
+int randomInteger(int low, int high) {
+   initRandomSeed();
+   double d = rand() / (double(RAND_MAX) + 1);
+   double s = d * (double(high) - low + 1);
+   return int(floor(low + s));
+}
+
+/*
+ * Implementation notes: randomReal
+ * --------------------------------
+ * The code for randomReal is similar to that for randomInteger,
+ * without the final conversion step.
+ */
+
+double randomReal(double low, double high) {
+   initRandomSeed();
+   double d = rand() / (double(RAND_MAX) + 1);
+   double s = d * (high - low);
+   return low + s;
+}
+
+/*
+ * Implementation notes: randomChance
+ * ----------------------------------
+ * The code for randomChance calls randomReal(0, 1) and then checks
+ * whether the result is less than the requested probability.
+ */
+
+bool randomChance(double p) {
+   initRandomSeed();
+   return randomReal(0, 1) < p;
+}
+
+/*
+ * Implementation notes: setRandomSeed
+ * -----------------------------------
+ * The setRandomSeed function simply forwards its argument to srand.
+ * The call to initRandomSeed is required to set the initialized flag.
+ */
+
+void setRandomSeed(int seed) {
+   initRandomSeed();
+   srand(seed);
+}
+
+/*
+ * Implementation notes: initRandomSeed
+ * ------------------------------------
+ * The initRandomSeed function declares a static variable that keeps track
+ * of whether the seed has been initialized.  The first time initRandomSeed
+ * is called, initialized is false, so the seed is set to the current time.
+ */
+
+static void initRandomSeed() {
+   static bool initialized = false;
+   if (!initialized) {
+      srand(int(time(NULL)));
+      initialized = true;
+   }
+}
diff --git a/labb8/lib/StanfordCPPLib/random.h b/labb8/lib/StanfordCPPLib/random.h
new file mode 100755
index 0000000..3286f8f
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/random.h
@@ -0,0 +1,58 @@
+/*
+ * File: random.h
+ * --------------
+ * This file exports functions for generating pseudorandom numbers.
+ */
+
+#ifndef _random_h
+#define _random_h
+
+/*
+ * Function: randomInteger
+ * Usage: int n = randomInteger(low, high);
+ * ----------------------------------------
+ * Returns a random integer in the range <code>low</code> to
+ * <code>high</code>, inclusive.
+ */
+
+int randomInteger(int low, int high);
+
+/*
+ * Function: randomReal
+ * Usage: double d = randomReal(low, high);
+ * ----------------------------------------
+ * Returns a random real number in the half-open interval
+ * [<code>low</code>&nbsp;..&nbsp;<code>high</code>).  A half-open
+ * interval includes the first endpoint but not the second, which
+ * means that the result is always greater than or equal to
+ * <code>low</code> but strictly less than <code>high</code>.
+ */
+
+double randomReal(double low, double high);
+
+/*
+ * Function: randomChance
+ * Usage: if (randomChance(p)) ...
+ * -------------------------------
+ * Returns <code>true</code> with the probability indicated by <code>p</code>.
+ * The argument <code>p</code> must be a floating-point number between
+ * 0 (never) and 1 (always).  For example, calling
+ * <code>randomChance(.30)</code> returns <code>true</code> 30 percent
+ * of the time.
+ */
+
+bool randomChance(double p);
+
+/*
+ * Function: setRandomSeed
+ * Usage: setRandomSeed(seed);
+ * ---------------------------
+ * Sets the internal random number seed to the specified value.  You
+ * can use this function to set a specific starting point for the
+ * pseudorandom sequence or to ensure that program behavior is
+ * repeatable during the debugging phase.
+ */
+
+void setRandomSeed(int seed);
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/set.h b/labb8/lib/StanfordCPPLib/set.h
new file mode 100755
index 0000000..4395fa5
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/set.h
@@ -0,0 +1,621 @@
+/*
+ * File: set.h
+ * -----------
+ * This file exports the <code>Set</code> class, which implements a
+ * collection for storing a set of distinct elements.
+ */
+
+#ifndef _set_h
+#define _set_h
+
+#include <iostream>
+#include "foreach.h"
+#include "map.h"
+#include "vector.h"
+
+/*
+ * Class: Set<ValueType>
+ * ---------------------
+ * This class stores a collection of distinct elements.
+ */
+
+template <typename ValueType>
+class Set {
+
+public:
+
+/*
+ * Constructor: Set
+ * Usage: Set<ValueType> set;
+ * --------------------------
+ * Creates an empty set of the specified element type.
+ */
+
+   Set();
+
+/*
+ * Destructor: ~Set
+ * ----------------
+ * Frees any heap storage associated with this set.
+ */
+
+   virtual ~Set();
+
+/*
+ * Method: size
+ * Usage: count = set.size();
+ * --------------------------
+ * Returns the number of elements in this set.
+ */
+
+   int size() const;
+
+/*
+ * Method: isEmpty
+ * Usage: if (set.isEmpty()) ...
+ * -----------------------------
+ * Returns <code>true</code> if this set contains no elements.
+ */
+
+   bool isEmpty() const;
+
+/*
+ * Method: add
+ * Usage: set.add(value);
+ * ----------------------
+ * Adds an element to this set, if it was not already there.  For
+ * compatibility with the STL <code>set</code> class, this method
+ * is also exported as <code>insert</code>.
+ */
+
+   void add(const ValueType & value);
+   void insert(const ValueType & value);
+
+/*
+ * Method: remove
+ * Usage: set.remove(value);
+ * -------------------------
+ * Removes an element from this set.  If the value was not
+ * contained in the set, no error is generated and the set
+ * remains unchanged.
+ */
+
+   void remove(const ValueType & value);
+
+/*
+ * Method: contains
+ * Usage: if (set.contains(value)) ...
+ * -----------------------------------
+ * Returns <code>true</code> if the specified value is in this set.
+ */
+
+   bool contains(const ValueType & value) const;
+
+/*
+ * Method: isSubsetOf
+ * Usage: if (set.isSubsetOf(set2)) ...
+ * ------------------------------------
+ * Implements the subset relation on sets.  It returns
+ * <code>true</code> if every element of this set is
+ * contained in <code>set2</code>.
+ */
+
+   bool isSubsetOf(const Set & set2) const;
+
+/*
+ * Method: clear
+ * Usage: set.clear();
+ * -------------------
+ * Removes all elements from this set.
+ */
+
+   void clear();
+
+/*
+ * Operator: ==
+ * Usage: set1 == set2
+ * -------------------
+ * Returns <code>true</code> if <code>set1</code> and <code>set2</code>
+ * contain the same elements.
+ */
+
+   bool operator==(const Set & set2) const;
+
+/*
+ * Operator: !=
+ * Usage: set1 != set2
+ * -------------------
+ * Returns <code>true</code> if <code>set1</code> and <code>set2</code>
+ * are different.
+ */
+
+   bool operator!=(const Set & set2) const;
+
+/*
+ * Operator: +
+ * Usage: set1 + set2
+ *        set1 + element
+ * ---------------------
+ * Returns the union of sets <code>set1</code> and <code>set2</code>, which
+ * is the set of elements that appear in at least one of the two sets.  The
+ * right hand set can be replaced by an element of the value type, in which
+ * case the operator returns a new set formed by adding that element.
+ */
+
+   Set operator+(const Set & set2) const;
+   Set operator+(const ValueType & element) const;
+
+/*
+ * Operator: *
+ * Usage: set1 * set2
+ * ------------------
+ * Returns the intersection of sets <code>set1</code> and <code>set2</code>,
+ * which is the set of all elements that appear in both.
+ */
+
+   Set operator*(const Set & set2) const;
+
+/*
+ * Operator: -
+ * Usage: set1 - set2
+ *        set1 - element
+ * ---------------------
+ * Returns the difference of sets <code>set1</code> and <code>set2</code>,
+ * which is all of the elements that appear in <code>set1</code> but
+ * not <code>set2</code>.  The right hand set can be replaced by an
+ * element of the value type, in which case the operator returns a new
+ * set formed by removing that element.
+ */
+
+   Set operator-(const Set & set2) const;
+   Set operator-(const ValueType & element) const;
+
+/*
+ * Operator: +=
+ * Usage: set1 += set2;
+ *        set1 += value;
+ * ---------------------
+ * Adds all of the elements from <code>set2</code> (or the single
+ * specified value) to <code>set1</code>.  As a convenience, the
+ * <code>Set</code> package also overloads the comma operator so
+ * that it is possible to initialize a set like this:
+ *
+ *<pre>
+ *    Set<int> digits;
+ *    digits += 0, 1, 2, 3, 4, 5, 6, 7, 8, 9;
+ *</pre>
+ */
+
+   Set & operator+=(const Set & set2);
+   Set & operator+=(const ValueType & value);
+
+/*
+ * Operator: *=
+ * Usage: set1 *= set2;
+ * --------------------
+ * Removes any elements from <code>set1</code> that are not present in
+ * <code>set2</code>.
+ */
+
+   Set & operator*=(const Set & set2);
+
+/*
+ * Operator: -=
+ * Usage: set1 -= set2;
+ *        set1 -= value;
+ * ---------------------
+ * Removes the elements from <code>set2</code> (or the single
+ * specified value) from <code>set1</code>.  As a convenience, the
+ * <code>Set</code> package also overloads the comma operator so
+ * that it is possible to remove multiple elements from a set
+ * like this:
+ *
+ *<pre>
+ *    digits -= 0, 2, 4, 6, 8;
+ *</pre>
+ *
+ * which removes the values 0, 2, 4, 6, and 8 from the set
+ * <code>digits</code>.
+ */
+
+   Set & operator-=(const Set & set2);
+   Set & operator-=(const ValueType & value);
+
+/*
+ * Method: first
+ * Usage: ValueType value = set.first();
+ * -------------------------------------
+ * Returns the first value in the set in the order established by the
+ * <code>foreach</code> macro.  If the set is empty, <code>first</code>
+ * generates an error.
+ */
+
+   ValueType first() const;
+
+/*
+ * Method: toString
+ * Usage: string str = set.toString();
+ * -----------------------------------
+ * Converts the set to a printable string representation.
+ */
+
+   std::string toString();
+
+/*
+ * Method: mapAll
+ * Usage: set.mapAll(fn);
+ * ----------------------
+ * Iterates through the elements of the set and calls <code>fn(value)</code>
+ * for each one.  The values are processed in ascending order, as defined
+ * by the comparison function.
+ */
+
+   void mapAll(void (*fn)(ValueType)) const;
+   void mapAll(void (*fn)(const ValueType &)) const;
+
+   template <typename FunctorType>
+   void mapAll(FunctorType fn) const;
+
+/*
+ * Additional Set operations
+ * -------------------------
+ * In addition to the methods listed in this interface, the Set class
+ * supports the following operations:
+ *
+ *   - Stream I/O using the << and >> operators
+ *   - Deep copying for the copy constructor and assignment operator
+ *   - Iteration using the range-based for statement and STL iterators
+ *
+ * The iteration forms process the Set in ascending order.
+ */
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in the file is logically part    */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+private:
+
+   Map<ValueType,bool> map;            /* Map used to store the element     */
+   bool removeFlag;                    /* Flag to differentiate += and -=   */
+
+public:
+
+/*
+ * Hidden features
+ * ---------------
+ * The remainder of this file consists of the code required to
+ * support the comma operator, deep copying, and iteration.
+ * Including these methods in the public interface would make
+ * that interface more difficult to understand for the average client.
+ */
+
+/* Extended constructors */
+
+   template <typename CompareType>
+   explicit Set(CompareType cmp) : map(Map<ValueType,bool>(cmp)) {
+      /* Empty */
+   }
+
+   Set & operator,(const ValueType & value) {
+      if (this->removeFlag) {
+         this->remove(value);
+      } else {
+         this->add(value);
+      }
+      return *this;
+   }
+
+/*
+ * Iterator support
+ * ----------------
+ * The classes in the StanfordCPPLib collection implement input
+ * iterators so that they work symmetrically with respect to the
+ * corresponding STL classes.
+ */
+
+   class iterator : public std::iterator<std::input_iterator_tag,ValueType> {
+
+   private:
+
+      typename Map<ValueType,bool>::iterator mapit;  /* Iterator for the map */
+
+   public:
+
+                iterator() {
+              /* Empty */
+      }
+
+      iterator(typename Map<ValueType,bool>::iterator it) : mapit(it) {
+         /* Empty */
+      }
+
+      iterator(const iterator & it) {
+         mapit = it.mapit;
+      }
+
+      iterator & operator++() {
+         ++mapit;
+         return *this;
+      }
+
+      iterator operator++(int) {
+         iterator copy(*this);
+         operator++();
+         return copy;
+      }
+
+      bool operator==(const iterator & rhs) {
+         return mapit == rhs.mapit;
+      }
+
+      bool operator!=(const iterator & rhs) {
+         return !(*this == rhs);
+      }
+
+      ValueType operator*() {
+         return *mapit;
+      }
+
+      ValueType *operator->() {
+         return mapit;
+      }
+   };
+
+   iterator begin() const {
+      return iterator(map.begin());
+   }
+
+   iterator end() const {
+      return iterator(map.end());
+   }
+
+};
+
+extern void error(std::string msg);
+
+template <typename ValueType>
+Set<ValueType>::Set() {
+   /* Empty */
+}
+
+template <typename ValueType>
+Set<ValueType>::~Set() {
+   /* Empty */
+}
+
+template <typename ValueType>
+int Set<ValueType>::size() const {
+   return map.size();
+}
+
+template <typename ValueType>
+bool Set<ValueType>::isEmpty() const {
+   return map.isEmpty();
+}
+
+template <typename ValueType>
+void Set<ValueType>::add(const ValueType & value) {
+   map.put(value, true);
+}
+
+template <typename ValueType>
+void Set<ValueType>::insert(const ValueType & value) {
+   map.put(value, true);
+}
+
+template <typename ValueType>
+void Set<ValueType>::remove(const ValueType & value) {
+   map.remove(value);
+}
+
+template <typename ValueType>
+bool Set<ValueType>::contains(const ValueType & value) const {
+   return map.containsKey(value);
+}
+
+template <typename ValueType>
+void Set<ValueType>::clear() {
+   map.clear();
+}
+
+template <typename ValueType>
+bool Set<ValueType>::isSubsetOf(const Set & set2) const {
+   iterator it = begin();
+   iterator end = this->end();
+   while (it != end) {
+      if (!set2.map.containsKey(*it)) return false;
+      ++it;
+   }
+   return true;
+}
+
+/*
+ * Implementation notes: set operators
+ * -----------------------------------
+ * The implementations for the set operators use iteration to walk
+ * over the elements in one or both sets.
+ */
+
+template <typename ValueType>
+bool Set<ValueType>::operator==(const Set & set2) const {
+   if (size() != set2.map.size()) return false;
+   iterator it1 = begin();
+   iterator it2 = set2.map.begin();
+   iterator end = this->end();
+   while (it1 != end) {
+      if (map.compareKeys(*it1, *it2) != 0) return false;
+      ++it1;
+      ++it2;
+   }
+   return true;
+}
+
+template <typename ValueType>
+bool Set<ValueType>::operator!=(const Set & set2) const {
+   return !(*this == set2);
+}
+
+template <typename ValueType>
+Set<ValueType> Set<ValueType>::operator+(const Set & set2) const {
+   Set<ValueType> set = *this;
+   foreach (ValueType value in set2) {
+      set.add(value);
+   }
+   return set;
+}
+
+template <typename ValueType>
+Set<ValueType> Set<ValueType>::operator+(const ValueType & element) const {
+   Set<ValueType> set = *this;
+   set.add(element);
+   return set;
+}
+
+template <typename ValueType>
+Set<ValueType> Set<ValueType>::operator*(const Set & set2) const {
+   Set<ValueType> set = *this;
+   set.clear();
+   foreach (ValueType value in *this) {
+      if (set2.contains(value)) set.add(value);
+   }
+   return set;
+}
+
+template <typename ValueType>
+Set<ValueType> Set<ValueType>::operator-(const Set & set2) const {
+   Set<ValueType> set = *this;
+   foreach (ValueType value in set2) {
+      set.remove(value);
+   }
+   return set;
+}
+
+template <typename ValueType>
+Set<ValueType> Set<ValueType>::operator-(const ValueType & element) const {
+   Set<ValueType> set = *this;
+   set.remove(element);
+   return set;
+}
+
+template <typename ValueType>
+Set<ValueType> & Set<ValueType>::operator+=(const Set & set2) {
+   foreach (ValueType value in set2) {
+      this->add(value);
+   }
+   return *this;
+}
+
+template <typename ValueType>
+Set<ValueType> & Set<ValueType>::operator+=(const ValueType & value) {
+   this->add(value);
+   this->removeFlag = false;
+   return *this;
+}
+
+template <typename ValueType>
+Set<ValueType> & Set<ValueType>::operator*=(const Set & set2) {
+   Vector<ValueType> toRemove;
+   foreach (ValueType value in *this) {
+      if (!set2.map.containsKey(value)) toRemove.add(value);
+   }
+   foreach (ValueType value in toRemove) {
+      this->remove(value);
+   }
+   return *this;
+}
+
+template <typename ValueType>
+Set<ValueType> & Set<ValueType>::operator-=(const Set & set2) {
+   Vector<ValueType> toRemove;
+   foreach (ValueType value in *this) {
+      if (set2.map.containsKey(value)) toRemove.add(value);
+   }
+   foreach (ValueType value in toRemove) {
+      this->remove(value);
+   }
+   return *this;
+}
+
+template <typename ValueType>
+Set<ValueType> & Set<ValueType>::operator-=(const ValueType & value) {
+   this->remove(value);
+   this->removeFlag = true;
+   return *this;
+}
+
+template <typename ValueType>
+ValueType Set<ValueType>::first() const {
+   if (isEmpty()) error("first: set is empty");
+   return *begin();
+}
+
+template <typename ValueType>
+std::string Set<ValueType>::toString() {
+   ostringstream os;
+   os << *this;
+   return os.str();
+}
+
+template <typename ValueType>
+void Set<ValueType>::mapAll(void (*fn)(ValueType)) const {
+   map.mapAll(fn);
+}
+
+template <typename ValueType>
+void Set<ValueType>::mapAll(void (*fn)(const ValueType &)) const {
+   map.mapAll(fn);
+}
+
+template <typename ValueType>
+template <typename FunctorType>
+void Set<ValueType>::mapAll(FunctorType fn) const {
+   map.mapAll(fn);
+}
+
+template <typename ValueType>
+std::ostream & operator<<(std::ostream & os, const Set<ValueType> & set) {
+   os << "{";
+   bool started = false;
+   foreach (ValueType value in set) {
+      if (started) os << ", ";
+      writeGenericValue(os, value, true);
+      started = true;
+   }
+   os << "}";
+   return os;
+}
+
+template <typename ValueType>
+std::istream & operator>>(std::istream & is, Set<ValueType> & set) {
+   char ch;
+   is >> ch;
+   if (ch != '{') error("operator >>: Missing {");
+   set.clear();
+   is >> ch;
+   if (ch != '}') {
+      is.unget();
+      while (true) {
+         ValueType value;
+         readGenericValue(is, value);
+         set += value;
+         is >> ch;
+         if (ch == '}') break;
+         if (ch != ',') {
+            error(std::string("operator >>: Unexpected character ") + ch);
+         }
+      }
+   }
+   return is;
+}
+
+// hashing functions for sets;  defined in hashmap.cpp
+int hashCode(const Set<std::string>& s);
+int hashCode(const Set<int>& s);
+int hashCode(const Set<char>& s);
+int hashCode(const Set<long>& s);
+int hashCode(const Set<double>& s);
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/simpio.cpp b/labb8/lib/StanfordCPPLib/simpio.cpp
new file mode 100755
index 0000000..4f91551
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/simpio.cpp
@@ -0,0 +1,67 @@
+/*
+ * File: simpio.cpp
+ * ----------------
+ * This file implements the simpio.h interface.
+ */
+
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include "simpio.h"
+using namespace std;
+
+/*
+ * Implementation notes: getInteger, getReal
+ * -----------------------------------------
+ * Each of these functions reads a complete input line and then uses the
+ * <sstream> library to parse that line into a value of the desired type.
+ * If that fails, the implementation asks the user for a new value.
+ */
+
+int getInteger(string prompt) {
+   int value;
+   string line;
+   while (true) {
+      cout << prompt;
+      getline(cin, line);
+      istringstream stream(line);
+      stream >> value >> ws;
+      if (!stream.fail() && stream.eof()) break;
+      cout << "Illegal integer format. Try again." << endl;
+      if (prompt == "") prompt = "Enter an integer: ";
+   }
+   return value;
+}
+
+double getReal(string prompt) {
+   double value;
+   string line;
+   while (true) {
+      cout << prompt;
+      getline(cin, line);
+      istringstream stream(line);
+      stream >> value >> ws;
+      if (!stream.fail() && stream.eof()) break;
+      cout << "Illegal numeric format. Try again." << endl;
+      if (prompt == "") prompt = "Enter a number: ";
+   }
+   return value;
+}
+
+/*
+ * Implementation notes: getLine
+ * -----------------------------
+ * The getLine function simply combines the process of displaying a
+ * prompt and reading an input line into a single call.  The primary
+ * reason for including this function in the library is to ensure
+ * that the process of reading integers, floating-point numbers, and
+ * strings remains as consistent as possible.
+ */
+
+string getLine(string prompt) {
+   string line;
+   cout << prompt;
+   getline(cin, line);
+   return line;
+}
diff --git a/labb8/lib/StanfordCPPLib/simpio.h b/labb8/lib/StanfordCPPLib/simpio.h
new file mode 100755
index 0000000..25c32c1
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/simpio.h
@@ -0,0 +1,53 @@
+/*
+ * File: simpio.h
+ * --------------
+ * This file exports a set of functions that simplify input/output
+ * operations in C++ and provide some error-checking on console input.
+ */
+
+#ifndef _simpio_h
+#define _simpio_h
+
+#include <string>
+
+/*
+ * Function: getInteger
+ * Usage: int n = getInteger(prompt);
+ * ----------------------------------
+ * Reads a complete line from <code>cin</code> and scans it as an
+ * integer. If the scan succeeds, the integer value is returned. If
+ * the argument is not a legal integer or if extraneous characters
+ * (other than whitespace) appear in the string, the user is given
+ * a chance to reenter the value. If supplied, the optional
+ * <code>prompt</code> string is printed before reading the value.
+ */
+
+int getInteger(std::string prompt = "");
+
+/*
+ * Function: getReal
+ * Usage: double x = getReal(prompt);
+ * ----------------------------------
+ * Reads a complete line from <code>cin</code> and scans it as a
+ * floating-point number. If the scan succeeds, the floating-point
+ * value is returned.  If the input is not a legal number or if
+ * extraneous characters (other than whitespace) appear in the string,
+ * the user is given a chance to reenter the value. If supplied, the
+ * optional <code>prompt</code> string is printed before reading the value.
+ */
+
+double getReal(std::string prompt = "");
+
+/*
+ * Function: getLine
+ * Usage: string line = getLine(prompt);
+ * -------------------------------------
+ * Reads a line of text from <code>cin</code> and returns that line
+ * as a string.  The newline character that terminates the input is
+ * not stored as part of the return value.  If supplied, the optional
+ * <code>prompt</code> string is printed before reading the value.
+ */
+
+std::string getLine(std::string prompt = "");
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/sound.cpp b/labb8/lib/StanfordCPPLib/sound.cpp
new file mode 100755
index 0000000..f0c4705
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/sound.cpp
@@ -0,0 +1,31 @@
+/*
+ * File: sound.cpp
+ * ---------------
+ * Implementation of the Sound class.
+ */
+
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
+#include "gevents.h"
+#include "gtypes.h"
+#include "sound.h"
+#include "vector.h"
+#include "platform.h"
+using namespace std;
+
+static Platform *pp = getPlatform();
+
+Sound::Sound(string filename) {
+   pp->createSound(this, filename);
+}
+
+Sound::~Sound() {
+   pp->deleteSound(this);
+}
+
+void Sound::play() {
+   pp->playSound(this);
+}
+
diff --git a/labb8/lib/StanfordCPPLib/sound.h b/labb8/lib/StanfordCPPLib/sound.h
new file mode 100755
index 0000000..89e2066
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/sound.h
@@ -0,0 +1,63 @@
+/*
+ * File: sound.h
+ * -------------
+ * This file defines a class that represents a sound.
+ */
+
+#ifndef _sound_h
+#define _sound_h
+
+/*
+ * Class: Sound
+ * ------------
+ * This class encapsulates a sound file.  The sound file is specified in the
+ * constructor and must be a file in either the current directory or a
+ * subdirectory named <code>sounds</code>.
+ *
+ * <p>The following code, for example, plays the sound file
+ * <code>ringtone.wav</code>:
+ *
+ *<pre>
+ *    Sound ringtone("ringtone.wav");
+ *    ringtone.play();
+ *</pre>
+ */
+
+class Sound {
+
+public:
+
+/*
+ * Constructor: Sound
+ * Usage: Sound sound;
+ *        Sound sound(filename);
+ * -----------------------------
+ * Creates a <code>Sound</code> object.  The default constructor
+ * creates an empty sound that cannot be played.  The second form
+ * initializes the sound by reading in the contents of the specified
+ * file.
+ */
+
+   Sound(std::string filename);
+
+/*
+ * Destructor: ~Sound
+ * ------------------
+ * Frees the memory associated with the sound.
+ */
+
+   virtual ~Sound();
+
+/*
+ * Method: play
+ * Usage: sound.play();
+ * --------------------
+ * Starts playing the sound.  This call returns immediately without waiting
+ * for the sound to finish.
+ */
+
+   void play();
+
+};
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/stack.h b/labb8/lib/StanfordCPPLib/stack.h
new file mode 100755
index 0000000..21d5058
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/stack.h
@@ -0,0 +1,285 @@
+/*
+ * File: stack.h
+ * -------------
+ * This file exports the <code>Stack</code> class, which implements
+ * a collection that processes values in a last-in/first-out (LIFO) order.
+ */
+
+#ifndef _stack_h
+#define _stack_h
+
+#include "vector.h"
+
+/*
+ * Class: Stack<ValueType>
+ * -----------------------
+ * This class models a linear structure called a <b><i>stack</i></b>
+ * in which values are added and removed only from one end.
+ * This discipline gives rise to a last-in/first-out behavior (LIFO)
+ * that is the defining feature of stacks.  The fundamental stack
+ * operations are <code>push</code> (add to top) and <code>pop</code>
+ * (remove from top).
+ */
+
+template <typename ValueType>
+class Stack {
+
+public:
+
+/*
+ * Constructor: Stack
+ * Usage: Stack<ValueType> stack;
+ * ------------------------------
+ * Initializes a new empty stack.
+ */
+
+   Stack();
+
+/*
+ * Destructor: ~Stack
+ * ------------------
+ * Frees any heap storage associated with this stack.
+ */
+
+   virtual ~Stack();
+
+/*
+ * Method: size
+ * Usage: int n = stack.size();
+ * ----------------------------
+ * Returns the number of values in this stack.
+ */
+
+   int size() const;
+
+/*
+ * Method: isEmpty
+ * Usage: if (stack.isEmpty()) ...
+ * -------------------------------
+ * Returns <code>true</code> if this stack contains no elements.
+ */
+
+   bool isEmpty() const;
+
+/*
+ * Method: clear
+ * Usage: stack.clear();
+ * ---------------------
+ * Removes all elements from this stack.
+ */
+
+   void clear();
+
+/*
+ * Method: push
+ * Usage: stack.push(value);
+ * -------------------------
+ * Pushes the specified value onto this stack.
+ */
+
+   void push(ValueType value);
+
+/*
+ * Method: pop
+ * Usage: ValueType top = stack.pop();
+ * -----------------------------------
+ * Removes the top element from this stack and returns it.  This
+ * method signals an error if called on an empty stack.
+ */
+
+   ValueType pop();
+
+/*
+ * Method: peek
+ * Usage: ValueType top = stack.peek();
+ * ------------------------------------
+ * Returns the value of top element from this stack, without removing
+ * it.  This method signals an error if called on an empty stack.  For
+ * compatibility with the STL classes, this method is also exported
+ * under the name <code>top</code>, in which case it returns the value
+ * by reference.
+ */
+
+   ValueType peek() const;
+   ValueType & top();
+
+/*
+ * Method: toString
+ * Usage: string str = stack.toString();
+ * -------------------------------------
+ * Converts the stack to a printable string representation.
+ */
+
+   std::string toString();
+
+/*
+ * Operator: ==
+ * Usage: stack1 == stack2
+ * -------------------
+ * Returns <code>true</code> if <code>stack1</code> and <code>stack2</code>
+ * contain the same elements.
+ */
+
+   bool operator==(const Stack & stack2) const;
+
+/*
+ * Operator: !=
+ * Usage: stack1 != stack2
+ * -------------------
+ * Returns <code>true</code> if <code>stack1</code> and <code>stack2</code>
+ * do not contain the same elements.
+ */
+
+   bool operator!=(const Stack & stack2) const;
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in the file is logically part    */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+/*
+ * Implementation notes: Stack data structure
+ * ------------------------------------------
+ * The easiest way to implement a stack is to store the elements in a
+ * Vector.  Doing so means that the problems of dynamic memory allocation
+ * and copy assignment are already solved by the implementation of the
+ * underlying Vector class.
+ */
+
+private:
+   Vector<ValueType> elements;
+
+};
+
+extern void error(std::string msg);
+
+/*
+ * Stack class implementation
+ * --------------------------
+ * The Stack is internally managed using a Vector.  This layered design
+ * makes the implementation extremely simple, to the point that most
+ * methods can be implemented in as single line.
+ */
+
+template <typename ValueType>
+Stack<ValueType>::Stack() {
+   /* Empty */
+}
+
+template <typename ValueType>
+Stack<ValueType>::~Stack() {
+   /* Empty */
+}
+
+template <typename ValueType>
+int Stack<ValueType>::size() const {
+   return elements.size();
+}
+
+template <typename ValueType>
+bool Stack<ValueType>::isEmpty() const {
+   return size() == 0;
+}
+
+template <typename ValueType>
+void Stack<ValueType>::push(ValueType value) {
+   elements.add(value);
+}
+
+template <typename ValueType>
+ValueType Stack<ValueType>::pop() {
+   if (isEmpty()) error("pop: Attempting to pop an empty stack");
+   ValueType top = elements[elements.size() - 1];
+   elements.remove(elements.size() - 1);
+   return top;
+}
+
+template <typename ValueType>
+ValueType Stack<ValueType>::peek() const {
+   if (isEmpty()) error("peek: Attempting to peek at an empty stack");
+   return elements.get(elements.size() - 1);
+}
+
+template <typename ValueType>
+ValueType & Stack<ValueType>::top() {
+   if (isEmpty()) error("top: Attempting to read top of an empty stack");
+   return elements[elements.size() - 1];
+}
+
+template <typename ValueType>
+void Stack<ValueType>::clear() {
+   elements.clear();
+}
+
+template <typename ValueType>
+std::string Stack<ValueType>::toString() {
+   ostringstream os;
+   os << *this;
+   return os.str();
+}
+
+template <typename ValueType>
+bool Stack<ValueType>::operator==(const Stack & stack2) const {
+   if (size() != stack2.size()) return false;
+   for (int i = 0; i < size(); i++) {
+       if (this->elements[i] != stack2.elements[i]) {
+           return false;
+       }
+   }
+   return true;
+}
+
+template <typename ValueType>
+bool Stack<ValueType>::operator!=(const Stack & stack2) const {
+   return !(*this == stack2);
+}
+
+template <typename ValueType>
+std::ostream & operator<<(std::ostream & os, const Stack<ValueType> & stack) {
+   os << "{";
+   Stack<ValueType> copy = stack;
+   Stack<ValueType> reversed;
+   while (!copy.isEmpty()) {
+      reversed.push(copy.pop());
+   }
+   int len = stack.size();
+   for (int i = 0; i < len; i++) {
+      if (i > 0) os << ", ";
+      writeGenericValue(os, reversed.pop(), true);
+   }
+   return os << "}";
+}
+
+template <typename ValueType>
+std::istream & operator>>(std::istream & is, Stack<ValueType> & stack) {
+   char ch;
+   is >> ch;
+   if (ch != '{') error("operator >>: Missing {");
+   stack.clear();
+   is >> ch;
+   if (ch != '}') {
+      is.unget();
+      while (true) {
+         ValueType value;
+         readGenericValue(is, value);
+         stack.push(value);
+         is >> ch;
+         if (ch == '}') break;
+         if (ch != ',') {
+            error(std::string("operator >>: Unexpected character ") + ch);
+         }
+      }
+   }
+   return is;
+}
+
+// hashing functions for stacks;  defined in hashmap.cpp
+int hashCode(const Stack<std::string>& s);
+int hashCode(const Stack<int>& s);
+int hashCode(const Stack<char>& s);
+int hashCode(const Stack<long>& s);
+int hashCode(const Stack<double>& s);
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/startup.cpp b/labb8/lib/StanfordCPPLib/startup.cpp
new file mode 100755
index 0000000..d6d3ff8
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/startup.cpp
@@ -0,0 +1,34 @@
+/*
+ * File: startup.cpp
+ * -----------------
+ * This file implements the wrapper for main that allows for
+ * system initialization and error handling.
+ */
+
+#include <cstdlib>
+#include <iostream>
+#include "error.h"
+using namespace std;
+
+#if defined (_MSC_VER) && (_MSC_VER >= 1200)
+#  include <windows.h>
+#  define MSC_ERROR_FLAGS (MB_OK | MB_ICONSTOP | MB_TOPMOST)
+#endif
+
+/* Global flag word indicating option for main */
+
+int _mainFlags;
+
+int mainWrapper(int argc, char **argv) {
+   extern int Main(int argc, char **argv);
+   try {
+      return Main(argc, argv);
+   } catch (ErrorException & ex) {
+      string msg = "Error: " + ex.getMessage();
+      cerr << msg << endl;
+#ifdef _MSC_VER
+      MessageBoxA(NULL, msg.c_str(), "Error!", MSC_ERROR_FLAGS);
+#endif
+      return EXIT_FAILURE;
+   }
+}
diff --git a/labb8/lib/StanfordCPPLib/strlib.cpp b/labb8/lib/StanfordCPPLib/strlib.cpp
new file mode 100755
index 0000000..7e53235
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/strlib.cpp
@@ -0,0 +1,252 @@
+/*
+ * File: strlib.cpp
+ * ----------------
+ * This file implements the strlib.h interface.
+ */
+
+#include <cctype>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include "error.h"
+#include "strlib.h"
+using namespace std;
+
+/* Function prototypes */
+
+/*
+ * Implementation notes: numeric conversion
+ * ----------------------------------------
+ * These functions use the <sstream> library to perform the conversion.
+ */
+
+string integerToString(int n) {
+   ostringstream stream;
+   stream << n;
+   return stream.str();
+}
+
+int stringToInteger(string str) {
+   istringstream stream(str);
+   int value;
+   stream >> value >> ws;
+   if (stream.fail() || !stream.eof()) {
+      error("stringToInteger: Illegal integer format (" + str + ")");
+   }
+   return value;
+}
+
+string realToString(double d) {
+   ostringstream stream;
+   stream << uppercase << d;
+   return stream.str();
+}
+
+double stringToReal(string str) {
+   istringstream stream(str);
+   double value;
+   stream >> value >> ws;
+   if (stream.fail() || !stream.eof()) {
+      error("stringToReal: Illegal floating-point format (" + str + ")");
+   }
+   return value;
+}
+
+/*
+ * Implementation notes: case conversion
+ * -------------------------------------
+ * The functions toUpperCase and toLowerCase return a new string whose
+ * characters appear in the desired case. These implementations rely on
+ * the fact that the characters in the string are copied when the
+ * argument is passed to the function, which makes it possible to change
+ * the case of the copy without affecting the original.
+ */
+
+string toUpperCase(string str) {
+   int nChars = str.length();
+   for (int i = 0; i < nChars; i++) {
+      str[i] = toupper(str[i]);
+   }
+   return str;
+}
+
+string toLowerCase(string str) {
+   int nChars = str.length();
+   for (int i = 0; i < nChars; i++) {
+      str[i] = tolower(str[i]);
+   }
+   return str;
+}
+
+/*
+ * Implementation notes: equalsIgnoreCase
+ * --------------------------------------
+ * This implementation uses a for loop to cycle through the characters in
+ * each string.  Converting each string to uppercase and then comparing
+ * the results makes for a shorter but less efficient implementation.
+ */
+
+bool equalsIgnoreCase(string s1, string s2) {
+   if (s1.length() != s2.length()) return false;
+   int nChars = s1.length();
+   for (int i = 0; i < nChars; i++) {
+      if (tolower(s1[i]) != tolower(s2[i])) return false;
+   }
+   return true;
+}
+
+/*
+ * Implementation notes: startsWith, endsWith
+ * ------------------------------------------
+ * These implementations are overloaded to allow the second argument to
+ * be either a string or a character.
+ */
+
+bool startsWith(string str, string prefix) {
+   if (str.length() < prefix.length()) return false;
+   int nChars = prefix.length();
+   for (int i = 0; i < nChars; i++) {
+      if (str[i] != prefix[i]) return false;
+   }
+   return true;
+}
+
+bool startsWith(string str, char prefix) {
+   return str.length() > 0 && str[0] == prefix;
+}
+
+bool endsWith(string str, string suffix) {
+   int nChars = suffix.length();
+   int start = str.length() - nChars;
+   if (start < 0) return false;
+   for (int i = 0; i < nChars; i++) {
+      if (str[start + i] != suffix[i]) return false;
+   }
+   return true;
+}
+
+bool endsWith(string str, char suffix) {
+   return str.length() > 0 && str[str.length() - 1] == suffix;
+}
+
+string trim(string str) {
+   int finish = str.length() - 1;
+   while (finish >= 0 && isspace(str[finish])) {
+      finish--;
+   }
+   int start = 0;
+   while (start <= finish && isspace(str[start])) {
+      start++;
+   }
+   return str.substr(start, finish - start + 1);
+}
+
+/*
+ * Implementation notes: readQuotedString and writeQuotedString
+ * ------------------------------------------------------------
+ * Most of the work in these functions has to do with escape sequences.
+ */
+
+static const string STRING_DELIMITERS = ",:)}]\n";
+
+bool stringNeedsQuoting(const string & str) {
+   int n = str.length();
+   for (int i = 0; i < n; i++) {
+      char ch = str[i];
+      if (isspace(ch)) return false;
+      if (STRING_DELIMITERS.find(ch) != string::npos) return true;
+   }
+   return false;
+}
+
+void readQuotedString(istream & is, string & str) {
+   str = "";
+   char ch;
+   while (is.get(ch) && isspace(ch)) {
+      /* Empty */
+   }
+   if (is.fail()) return;
+   if (ch == '\'' || ch == '"') {
+      char delim = ch;
+      while (is.get(ch) && ch != delim) {
+         if (is.fail()) error("Unterminated string");
+         if (ch == '\\') {
+            if (!is.get(ch)) error("Unterminated string");
+            if (isdigit(ch) || ch == 'x') {
+               int maxDigits = 3;
+               int base = 8;
+               if (ch == 'x') {
+                  base = 16;
+                  maxDigits = 2;
+               }
+               int result = 0;
+               int digit = 0;
+               for (int i = 0; i < maxDigits && ch != delim; i++) {
+                  if (isdigit(ch)) {
+                     digit = ch - '0';
+                  } else if (base == 16 && isxdigit(ch)) {
+                     digit = toupper(ch) - 'A' + 10;
+                  } else {
+                     break;
+                  }
+                  result = base * result + digit;
+                  if (!is.get(ch)) error("Unterminated string");
+               }
+               ch = char(result);
+               is.unget();
+            } else {
+               switch (ch) {
+                case 'a': ch = '\a'; break;
+                case 'b': ch = '\b'; break;
+                case 'f': ch = '\f'; break;
+                case 'n': ch = '\n'; break;
+                case 'r': ch = '\r'; break;
+                case 't': ch = '\t'; break;
+                case 'v': ch = '\v'; break;
+                case '"': ch = '"'; break;
+                case '\'': ch = '\''; break;
+                case '\\': ch = '\\'; break;
+               }
+            }
+         }
+         str += ch;
+      }
+   } else {
+      str += ch;
+      int endTrim = 0;
+      while (is.get(ch) && STRING_DELIMITERS.find(ch) == string::npos) {
+         str += ch;
+         if (!isspace(ch)) endTrim = str.length();
+      }
+      if (is) is.unget();
+      str = str.substr(0, endTrim);
+   }
+}
+
+void writeQuotedString(ostream & os, const string & str, bool forceQuotes) {
+   if (!forceQuotes && stringNeedsQuoting(str)) forceQuotes = true;
+   if (forceQuotes) os << '"';
+   int len = str.length();
+   for (int i = 0; i < len; i++) {
+      char ch = str.at(i);
+      switch (ch) {
+       case '\a': os << "\\a"; break;
+       case '\b': os << "\\b"; break;
+       case '\f': os << "\\f"; break;
+       case '\n': os << "\\n"; break;
+       case '\r': os << "\\r"; break;
+       case '\t': os << "\\t"; break;
+       case '\v': os << "\\v"; break;
+       case '\\': os << "\\\\"; break;
+       default:
+         if (isprint(ch) && ch != '"') {
+            os << ch;
+         } else {
+            ostringstream oss;
+            oss << oct << setw(3) << setfill('0') << (int(ch) & 0xFF);
+            os << "\\" << oss.str();
+         }
+      }
+   }
+   if (forceQuotes) os << '"';
+}
diff --git a/labb8/lib/StanfordCPPLib/strlib.h b/labb8/lib/StanfordCPPLib/strlib.h
new file mode 100755
index 0000000..bb27629
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/strlib.h
@@ -0,0 +1,222 @@
+/*
+ * File: strlib.h
+ * --------------
+ * This file exports several useful string functions that are not
+ * included in the C++ string library.
+ */
+
+#ifndef _strlib_h
+#define _strlib_h
+
+#include <iostream>
+#include <sstream>
+#include <string>
+
+/*
+ * Function: integerToString
+ * Usage: string s = integerToString(n);
+ * -------------------------------------
+ * Converts an integer into the corresponding string of digits.
+ * For example, calling <code>integerToString(123)</code> returns
+ * the string <code>"123"</code>.
+ */
+
+std::string integerToString(int n);
+
+/*
+ * Function: stringToInteger
+ * Usage: int n = stringToInteger(str);
+ * ------------------------------------
+ * Converts a string of digits into an integer.  If the string is not a
+ * legal integer or contains extraneous characters other than whitespace,
+ * <code>stringToInteger</code> calls <code>error</code> with an
+ * appropriate message.
+ */
+
+int stringToInteger(std::string str);
+
+/*
+ * Function: realToString
+ * Usage: string s = realToString(d);
+ * ----------------------------------
+ * Converts a floating-point number into the corresponding string form.
+ * For example, calling <code>realToString(23.45)</code> returns
+ * the string <code>"23.45"</code>.
+ */
+
+std::string realToString(double d);
+
+/*
+ * Function: stringToReal
+ * Usage: double d = stringToReal(str);
+ * ------------------------------------
+ * Converts a string representing a real number into its corresponding
+ * value.  If the string is not a legal floating-point number or contains
+ * extraneous characters other than whitespace, <code>stringToReal</code>
+ * calls <code>error</code> with an appropriate message.
+ */
+
+double stringToReal(std::string str);
+
+/*
+ * Function: toUpperCase
+ * Usage: string s = toUpperCase(str);
+ * -----------------------------------
+ * Returns a new string in which all lowercase characters have been converted
+ * into their uppercase equivalents.
+ */
+
+std::string toUpperCase(std::string str);
+
+/*
+ * Function: toLowerCase
+ * Usage: string s = toLowerCase(str);
+ * -----------------------------------
+ * Returns a new string in which all uppercase characters have been converted
+ * into their lowercase equivalents.
+ */
+
+std::string toLowerCase(std::string str);
+
+/*
+ * Function: equalsIgnoreCase
+ * Usage: if (equalsIgnoreCase(s1, s2)) ...
+ * ----------------------------------------
+ * Returns <code>true</code> if <code>s1</code> and <code>s2</code> are
+ * equal discounting differences in case.
+ */
+
+bool equalsIgnoreCase(std::string s1, std::string s2);
+
+/*
+ * Function: startsWith
+ * Usage: if (startsWith(str, prefix)) ...
+ * ---------------------------------------
+ * Returns <code>true</code> if the string <code>str</code> starts with
+ * the specified prefix, which may be either a string or a character.
+ */
+
+bool startsWith(std::string str, std::string prefix);
+bool startsWith(std::string str, char prefix);
+
+/*
+ * Function: endsWith
+ * Usage: if (endsWith(str, suffix)) ...
+ * -------------------------------------
+ * Returns <code>true</code> if the string <code>str</code> ends with
+ * the specified suffix, which may be either a string or a character.
+ */
+
+bool endsWith(std::string str, std::string suffix);
+bool endsWith(std::string str, char suffix);
+
+/*
+ * Function: trim
+ * Usage: string trimmed = trim(str);
+ * ----------------------------------
+ * Returns a new string after removing any whitespace characters
+ * from the beginning and end of the argument.
+ */
+
+std::string trim(std::string str);
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in the file is logically part    */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+/*
+ * Friend function: writeQuotedString
+ * Usage: writeQuotedString(outfile, str, forceQuotes);
+ * ----------------------------------------------------
+ * Writes the string str to outfile surrounded by double quotes, converting
+ * special characters to escape sequences, as necessary.  If the optional
+ * parameter forceQuotes is explicitly set to false, quotes are included
+ * in the output only if necessary.
+ */
+
+void writeQuotedString(std::ostream & os, const std::string & str,
+                       bool forceQuotes = true);
+
+/*
+ * Friend function: readQuotedString
+ * Usage: readQuotedString(infile, str);
+ * -------------------------------------
+ * Reads the next string from infile into the reference parameter str.
+ * If the first character (other than whitespace) is either a single
+ * or a double quote, this function reads characters up to the
+ * matching quote, processing standard escape sequences as it goes.
+ * If not, readString reads characters up to any of the characters
+ * in the string STRING_DELIMITERS in the implementation file.
+ */
+
+void readQuotedString(std::istream & is, std::string & str);
+
+/*
+ * Friend function: stringNeedsQuoting
+ * Usage: if (stringNeedsQuoting(str)) ...
+ * ---------------------------------------
+ * Checks whether the string needs quoting in order to be read correctly.
+ */
+
+bool stringNeedsQuoting(const std::string & str);
+
+/*
+ * Friend function: writeGenericValue
+ * Usage: writeGenericValue(os, value, forceQuotes);
+ * -------------------------------------------------
+ * Writes a generic value to the output stream.  If that value is a string,
+ * this function uses writeQuotedString to write the value.
+ */
+
+template <typename ValueType>
+void writeGenericValue(std::ostream & os, const ValueType & value,
+                       bool) {
+   os << value;
+}
+
+template <>
+inline void writeGenericValue(std::ostream & os, const std::string & value,
+                              bool forceQuotes) {
+   writeQuotedString(os, value, forceQuotes);
+}
+
+template <typename ValueType>
+inline std::string genericValueToString(const ValueType & value,
+                              bool forceQuotes = false) {
+    std::ostringstream os;
+    writeGenericValue(os, value, forceQuotes);
+    return os.str();
+}
+
+template <>
+inline std::string genericValueToString(const std::string & value,
+                              bool forceQuotes) {
+    std::ostringstream os;
+    writeQuotedString(os, value, forceQuotes);
+    return os.str();
+}
+
+
+/*
+ * Friend function: readGenericValue
+ * Usage: readGenericValue(is, value);
+ * -----------------------------------
+ * Reads a generic value from the input stream.  If that value is a string,
+ * this function uses readQuotedString to read the value.
+ */
+
+template <typename ValueType>
+void readGenericValue(std::istream & is, ValueType & value) {
+   is >> value;
+}
+
+template <>
+inline void readGenericValue(std::istream & is, std::string & value) {
+   readQuotedString(is, value);
+}
+
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/tokenscanner.cpp b/labb8/lib/StanfordCPPLib/tokenscanner.cpp
new file mode 100755
index 0000000..6dadd0e
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/tokenscanner.cpp
@@ -0,0 +1,411 @@
+/*
+ * File: tokenscanner.cpp
+ * ----------------------
+ * Implementation for the TokenScanner class.
+ */
+
+#include <cctype>
+#include <iostream>
+#include "error.h"
+#include "tokenscanner.h"
+#include "strlib.h"
+#include "stack.h"
+using namespace std;
+
+TokenScanner::TokenScanner() {
+   initScanner();
+   setInput("");
+}
+
+TokenScanner::TokenScanner(string str) {
+   initScanner();
+   setInput(str);
+}
+
+TokenScanner::TokenScanner(istream & infile) {
+   initScanner();
+   setInput(infile);
+}
+
+TokenScanner::~TokenScanner() {
+   if (stringInputFlag) delete isp;
+}
+
+void TokenScanner::setInput(string str) {
+   stringInputFlag = true;
+   buffer = str;
+   isp = new istringstream(buffer);
+   savedTokens = NULL;
+}
+
+void TokenScanner::setInput(istream & infile) {
+   stringInputFlag = false;
+   isp = &infile;
+   savedTokens = NULL;
+}
+
+bool TokenScanner::hasMoreTokens() {
+   string token = nextToken();
+   saveToken(token);
+   return (token != "");
+}
+
+string TokenScanner::nextToken() {
+   if (savedTokens != NULL) {
+      StringCell *cp = savedTokens;
+      string token = cp->str;
+      savedTokens = cp->link;
+      delete cp;
+      return token;
+   }
+   while (true) {
+      if (ignoreWhitespaceFlag) skipSpaces();
+      int ch = isp->get();
+      if (ch == '/' && ignoreCommentsFlag) {
+         ch = isp->get();
+         if (ch == '/') {
+            while (true) {
+               ch = isp->get();
+               if (ch == '\n' || ch == '\r' || ch == EOF) break;
+            }
+            continue;
+         } else if (ch == '*') {
+            int prev = EOF;
+            while (true) {
+               ch = isp->get();
+               if (ch == EOF || (prev == '*' && ch == '/')) break;
+               prev = ch;
+            }
+            continue;
+         }
+         if (ch != EOF) isp->unget();
+         ch = '/';
+      }
+      if (ch == EOF) return "";
+      if ((ch == '"' || ch == '\'') && scanStringsFlag) {
+         isp->unget();
+         return scanString();
+      }
+      if (isdigit(ch) && scanNumbersFlag) {
+         isp->unget();
+         return scanNumber();
+      }
+      if (isWordCharacter(ch)) {
+         isp->unget();
+         return scanWord();
+      }
+      string op = string(1, ch);
+      while (isOperatorPrefix(op)) {
+         ch = isp->get();
+         if (ch == EOF) break;
+         op += ch;
+      }
+      while (op.length() > 1 && !isOperator(op)) {
+         isp->unget();
+         op.erase(op.length() - 1, 1);
+      }
+      return op;
+   }
+}
+
+void TokenScanner::saveToken(string token) {
+   StringCell *cp = new StringCell;
+   cp->str = token;
+   cp->link = savedTokens;
+   savedTokens = cp;
+}
+
+void TokenScanner::ignoreWhitespace() {
+   ignoreWhitespaceFlag = true;
+}
+
+void TokenScanner::ignoreComments() {
+   ignoreCommentsFlag = true;
+}
+
+void TokenScanner::scanNumbers() {
+   scanNumbersFlag = true;
+}
+
+void TokenScanner::scanStrings() {
+   scanStringsFlag = true;
+}
+
+void TokenScanner::addWordCharacters(string str) {
+   wordChars += str;
+}
+
+void TokenScanner::addOperator(string op) {
+   StringCell *cp = new StringCell;
+   cp->str = op;
+   cp->link = operators;
+   operators = cp;
+}
+
+int TokenScanner::getPosition() const {
+   if (savedTokens == NULL) {
+      return int(isp->tellg());
+   } else {
+      return int(isp->tellg()) - savedTokens->str.length();
+   }
+   return -1;
+}
+
+bool TokenScanner::isWordCharacter(char ch) const {
+   return isalnum(ch) || wordChars.find(ch) != string::npos;
+};
+
+void TokenScanner::verifyToken(string expected) {
+   string token = nextToken();
+   if (token != expected) {
+      string msg = "Found \"" + token + "\"" +
+                   " when expecting \"" + expected + "\"";
+      error(msg);
+   }
+};
+
+TokenType TokenScanner::getTokenType(string token) const {
+   if (token == "") return TokenType(EOF);
+   char ch = token[0];
+   if (isspace(ch)) return SEPARATOR;
+   if (ch == '"' || (ch == '\'' && token.length() > 1)) return STRING;
+   if (isdigit(ch)) return NUMBER;
+   if (isWordCharacter(ch)) return WORD;
+   return OPERATOR;
+};
+
+string TokenScanner::getStringValue(string token) const {
+   string str = "";
+   int start = 0;
+   int finish = token.length();
+   if (finish > 1 && (token[0] == '"' || token[0] == '\'')) {
+      start = 1;
+      finish--;
+   }
+   for (int i = start; i < finish; i++) {
+      char ch = token[i];
+      if (ch == '\\') {
+         ch = token[++i];
+         if (isdigit(ch) || ch == 'x') {
+            int base = 8;
+            if (ch == 'x') {
+               base = 16;
+               i++;
+            }
+            int result = 0;
+            int digit = 0;
+            while (i < finish) {
+               ch = token[i];
+               if (isdigit(ch)) {
+                  digit = ch - '0';
+               } else if (isalpha(ch)) {
+                  digit = toupper(ch) - 'A' + 10;
+               } else {
+                  digit = base;
+               }
+               if (digit >= base) break;
+               result = base * result + digit;
+               i++;
+            }
+            ch = char(result);
+            i--;
+         } else {
+            switch (ch) {
+             case 'a': ch = '\a'; break;
+             case 'b': ch = '\b'; break;
+             case 'f': ch = '\f'; break;
+             case 'n': ch = '\n'; break;
+             case 'r': ch = '\r'; break;
+             case 't': ch = '\t'; break;
+             case 'v': ch = '\v'; break;
+             case '"': ch = '"'; break;
+             case '\'': ch = '\''; break;
+             case '\\': ch = '\\'; break;
+            }
+         }
+      }
+      str += ch;
+   }
+   return str;
+}
+
+int TokenScanner::getChar() {
+   return isp->get();
+}
+
+void TokenScanner::ungetChar(int) {
+   isp->unget();
+}
+
+/* Private methods */
+
+void TokenScanner::initScanner() {
+   ignoreWhitespaceFlag = false;
+   ignoreCommentsFlag = false;
+   scanNumbersFlag = false;
+   scanStringsFlag = false;
+   operators = NULL;
+}
+
+/*
+ * Implementation notes: skipSpaces
+ * --------------------------------
+ * Advances the position of the scanner until the current character is
+ * not a whitespace character.
+ */
+
+void TokenScanner::skipSpaces() {
+   while (true) {
+      int ch = isp->get();
+      if (ch == EOF) return;
+      if (!isspace(ch)) {
+         isp->unget();
+         return;
+      }
+   }
+}
+
+/*
+ * Implementation notes: scanWord
+ * ------------------------------
+ * Reads characters until the scanner reaches the end of a sequence
+ * of word characters.
+ */
+
+string TokenScanner::scanWord() {
+   string token = "";
+   while (true) {
+      int ch = isp->get();
+      if (ch == EOF) break;
+      if (!isWordCharacter(ch)) {
+         isp->unget();
+         break;
+      }
+      token += char(ch);
+   }
+   return token;
+}
+
+/*
+ * Implementation notes: scanNumber
+ * --------------------------------
+ * Reads characters until the scanner reaches the end of a legal number.
+ * The function operates by simulating what computer scientists
+ * call a finite-state machine.  The program uses the variable
+ * <code>state</code> to record the history of the process and
+ * determine what characters would be legal at this point in time.
+ */
+
+string TokenScanner::scanNumber() {
+   string token = "";
+   NumberScannerState state = INITIAL_STATE;
+   while (state != FINAL_STATE) {
+      int ch = isp->get();
+      switch (state) {
+       case INITIAL_STATE:
+         if (!isdigit(ch)) {
+            error("Internal error: illegal call to scanNumber");
+         }
+         state = BEFORE_DECIMAL_POINT;
+         break;
+       case BEFORE_DECIMAL_POINT:
+         if (ch == '.') {
+            state = AFTER_DECIMAL_POINT;
+         } else if (ch == 'E' || ch == 'e') {
+            state = STARTING_EXPONENT;
+         } else if (!isdigit(ch)) {
+            if (ch != EOF) isp->unget();
+            state = FINAL_STATE;
+         }
+         break;
+       case AFTER_DECIMAL_POINT:
+         if (ch == 'E' || ch == 'e') {
+            state = STARTING_EXPONENT;
+         } else if (!isdigit(ch)) {
+            if (ch != EOF) isp->unget();
+            state = FINAL_STATE;
+         }
+         break;
+       case STARTING_EXPONENT:
+         if (ch == '+' || ch == '-') {
+            state = FOUND_EXPONENT_SIGN;
+         } else if (isdigit(ch)) {
+            state = SCANNING_EXPONENT;
+         } else {
+            if (ch != EOF) isp->unget();
+            isp->unget();
+            state = FINAL_STATE;
+         }
+         break;
+       case FOUND_EXPONENT_SIGN:
+         if (isdigit(ch)) {
+            state = SCANNING_EXPONENT;
+         } else {
+            if (ch != EOF) isp->unget();
+            isp->unget();
+            isp->unget();
+            state = FINAL_STATE;
+         }
+         break;
+       case SCANNING_EXPONENT:
+         if (!isdigit(ch)) {
+            if (ch != EOF) isp->unget();
+            state = FINAL_STATE;
+         }
+         break;
+       default:
+         state = FINAL_STATE;
+         break;
+      }
+      if (state != FINAL_STATE) {
+         token += char(ch);
+      }
+   }
+   return token;
+}
+
+/*
+ * Implementation notes: scanString
+ * --------------------------------
+ * Reads and returns a quoted string from the scanner, continuing until
+ * it scans the matching delimiter.  The scanner generates an error if
+ * there is no closing quotation mark before the end of the input.
+ */
+
+string TokenScanner::scanString() {
+   string token = "";
+   char delim = isp->get();
+   token += delim;
+   bool escape = false;
+   while (true) {
+      int ch = isp->get();
+      if (ch == EOF) error("TokenScanner found unterminated string");
+      if (ch == delim && !escape) break;
+      escape = (ch == '\\') && !escape;
+      token += ch;
+   }
+   return token + delim;
+}
+
+/*
+ * Implementation notes: isOperator, isOperatorPrefix
+ * --------------------------------------------------
+ * These methods search the list of operators and return true if the
+ * specified operator is either in the list or a prefix of an operator
+ * in the list, respectively.  This code could be made considerably more
+ * efficient by implementing operators as a trie.
+ */
+
+bool TokenScanner::isOperator(string op) {
+   for (StringCell *cp = operators; cp != NULL; cp = cp->link) {
+      if (op == cp->str) return true;
+   }
+   return false;
+}
+
+bool TokenScanner::isOperatorPrefix(string op) {
+   for (StringCell *cp = operators; cp != NULL; cp = cp->link) {
+      if (startsWith(cp->str, op)) return true;
+   }
+   return false;
+}
diff --git a/labb8/lib/StanfordCPPLib/tokenscanner.h b/labb8/lib/StanfordCPPLib/tokenscanner.h
new file mode 100755
index 0000000..0b2eb32
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/tokenscanner.h
@@ -0,0 +1,351 @@
+/*
+ * File: tokenscanner.h
+ * --------------------
+ * This file exports a <code>TokenScanner</code> class that divides
+ * a string into individual logical units called <b><i>tokens</i></b>.
+ */
+
+#ifndef _tokenscanner_h
+#define _tokenscanner_h
+
+#include <iostream>
+#include <string>
+#include "private/tokenpatch.h"
+
+/*
+ * Type: TokenType
+ * ---------------
+ * This enumerated type defines the values of the
+ * <code>getTokenType</code> method.
+ */
+
+#ifdef _WIN32
+#  define TokenType TokenTypeT
+#  define WORD WORD_TC
+#endif
+
+enum TokenType { SEPARATOR, WORD, NUMBER, STRING, OPERATOR };
+
+/*
+ * Class: TokenScanner
+ * -------------------
+ * This class divides a string into individual tokens.  The typical
+ * use of the <code>TokenScanner</code> class is illustrated by the
+ * following pattern, which reads the tokens in the string variable
+ * <code>input</code>:
+ *
+ *<pre>
+ *    TokenScanner scanner(input);
+ *    while (scanner.hasMoreTokens()) {
+ *       string token = scanner.nextToken();
+ *       ... process the token ...
+ *    }
+ *</pre>
+ *
+ * The <code>TokenScanner</code> class exports several additional methods
+ * that give clients more control over its behavior.  Those methods are
+ * described individually in the documentation.
+ */
+
+class TokenScanner {
+
+public:
+
+/*
+ * Constructor: TokenScanner
+ * Usage: TokenScanner scanner;
+ *        TokenScanner scanner(str);
+ *        TokenScanner scanner(infile);
+ * ------------------------------------
+ * Initializes a scanner object.  The initial token stream comes from
+ * the specified string or input stream, if supplied.  The default
+ * constructor creates a scanner with an empty token stream.
+ */
+
+   TokenScanner();
+   TokenScanner(std::string str);
+   TokenScanner(std::istream & infile);
+
+/*
+ * Destructor: ~TokenScanner
+ * -------------------------
+ * Deallocates the storage associated with this scanner.
+ */
+
+   virtual ~TokenScanner();
+
+/*
+ * Method: setInput
+ * Usage: scanner.setInput(str);
+ *        scanner.setInput(infile);
+ * --------------------------------
+ * Sets the token stream for this scanner to the specified string or
+ * input stream.  Any previous token stream is discarded.
+ */
+
+   void setInput(std::string str);
+   void setInput(std::istream & infile);
+
+/*
+ * Method: hasMoreTokens
+ * Usage: if (scanner.hasMoreTokens()) ...
+ * ---------------------------------------
+ * Returns <code>true</code> if there are additional tokens for this
+ * scanner to read.
+ */
+
+   bool hasMoreTokens();
+
+/*
+ * Method: nextToken
+ * Usage: token = scanner.nextToken();
+ * -----------------------------------
+ * Returns the next token from this scanner.  If <code>nextToken</code>
+ * is called when no tokens are available, it returns the empty string.
+ */
+
+   std::string nextToken();
+
+/*
+ * Method: saveToken
+ * Usage: scanner.saveToken(token);
+ * --------------------------------
+ * Pushes the specified token back into this scanner's input stream.
+ * On the next call to <code>nextToken</code>, the scanner will return
+ * the saved token without reading any additional characters from the
+ * token stream.
+ */
+
+   void saveToken(std::string token);
+
+/*
+ * Method: getPosition
+ * Usage: int pos = scanner.getPosition();
+ * ---------------------------------------
+ * Returns the current position of the scanner in the input stream.
+ * If <code>saveToken</code> has been called, this position corresponds
+ * to the beginning of the saved token.  If <code>saveToken</code> is
+ * called more than once, <code>getPosition</code> returns -1.
+ */
+
+   int getPosition() const;
+
+/*
+ * Method: ignoreWhitespace
+ * Usage: scanner.ignoreWhitespace();
+ * ----------------------------------
+ * Tells the scanner to ignore whitespace characters.  By default,
+ * the <code>nextToken</code> method treats whitespace characters
+ * (typically spaces and tabs) just like any other punctuation mark
+ * and returns them as single-character tokens.
+ * Calling
+ *
+ *<pre>
+ *    scanner.ignoreWhitespace();
+ *</pre>
+ *
+ * changes this behavior so that the scanner ignore whitespace characters.
+ */
+
+   void ignoreWhitespace();
+
+/*
+ * Method: ignoreComments
+ * Usage: scanner.ignoreComments();
+ * --------------------------------
+ * Tells the scanner to ignore comments.  The scanner package recognizes
+ * both the slash-star and slash-slash comment format from the C-based
+ * family of languages.  Calling
+ *
+ *<pre>
+ *    scanner.ignoreComments();
+ *</pre>
+ *
+ * sets the parser to ignore comments.
+ */
+
+   void ignoreComments();
+
+/*
+ * Method: scanNumbers
+ * Usage: scanner.scanNumbers();
+ * -----------------------------
+ * Controls how the scanner treats tokens that begin with a digit.  By
+ * default, the <code>nextToken</code> method treats numbers and letters
+ * identically and therefore does not provide any special processing for
+ * numbers.  Calling
+ *
+ *<pre>
+ *    scanner.scanNumbers();
+ *</pre>
+ *
+ * changes this behavior so that <code>nextToken</code> returns the
+ * longest substring that can be interpreted as a real number.
+ */
+
+   void scanNumbers();
+
+/*
+ * Method: scanStrings
+ * Usage: scanner.scanStrings();
+ * -----------------------------
+ * Controls how the scanner treats tokens enclosed in quotation marks.  By
+ * default, quotation marks (either single or double) are treated just like
+ * any other punctuation character.  Calling
+ *
+ *<pre>
+ *    scanner.scanStrings();
+ *</pre>
+ *
+ * changes this assumption so that <code>nextToken</code> returns a single
+ * token consisting of all characters through the matching quotation mark.
+ * The quotation marks are returned as part of the scanned token so that
+ * clients can differentiate strings from other token types.
+ */
+
+   void scanStrings();
+
+/*
+ * Method: addWordCharacters
+ * Usage: scanner.addWordCharacters(str);
+ * --------------------------------------
+ * Adds the characters in <code>str</code> to the set of characters
+ * legal in a <code>WORD</code> token.  For example, calling
+ * <code>addWordCharacters("_")</code> adds the underscore to the
+ * set of characters that are accepted as part of a word.
+ */
+
+   void addWordCharacters(std::string str);
+
+/*
+ * Method: isWordCharacter
+ * Usage: if (scanner.isWordCharacter(ch)) ...
+ * -------------------------------------------
+ * Returns <code>true</code> if the character is valid in a word.
+ */
+
+   bool isWordCharacter(char ch) const;
+
+/*
+ * Method: addOperator
+ * Usage: scanner.addOperator(op);
+ * -------------------------------
+ * Defines a new multicharacter operator.  Whenever you call
+ * <code>nextToken</code> when the input stream contains operator
+ * characters, the scanner returns the longest possible operator
+ * string that can be read at that point.
+ */
+
+   void addOperator(std::string op);
+
+/*
+ * Method: verifyToken
+ * Usage: scanner.verifyToken(expected);
+ * -------------------------------------
+ * Reads the next token and makes sure it matches the string
+ * <code>expected</code>.  If it does not, <code>verifyToken</code>
+ * throws an error.
+ */
+
+   void verifyToken(std::string expected);
+
+/*
+ * Method: getTokenType
+ * Usage: TokenType type = scanner.getTokenType(token);
+ * ----------------------------------------------------
+ * Returns the type of this token.  This type will match one of the
+ * following enumerated type constants: <code>EOF</code>,
+ * <code>SEPARATOR</code>, <code>WORD</code>, <code>NUMBER</code>,
+ * <code>STRING</code>, or <code>OPERATOR</code>.
+ */
+
+TokenType getTokenType(std::string token) const;
+
+/*
+ * Method: getChar
+ * Usage: int ch = scanner.getChar();
+ * ----------------------------------
+ * Reads the next character from the scanner input stream.
+ */
+
+int getChar();
+
+/*
+ * Method: ungetChar
+ * Usage: scanner.ungetChar(ch);
+ * -----------------------------
+ * Pushes the character <code>ch</code> back into the scanner stream.
+ * The character must match the one that was read.
+ */
+
+void ungetChar(int ch);
+
+/*
+ * Method: getStringValue
+ * Usage: string str = scanner.getStringValue(token);
+ * --------------------------------------------------
+ * Returns the string value of a token.  This value is formed by removing
+ * any surrounding quotation marks and replacing escape sequences by the
+ * appropriate characters.
+ */
+
+   std::string getStringValue(std::string token) const;
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in the file is logically part    */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+private:
+
+/*
+ * Private type: StringCell
+ * ------------------------
+ * This type is used to construct linked lists of cells, which are used
+ * to represent both the stack of saved tokens and the set of defined
+ * operators.  These types cannot use the Stack and Lexicon classes
+ * directly because tokenscanner.h is an extremely low-level interface,
+ * and doing so would create circular dependencies in the .h files.
+ */
+
+   struct StringCell {
+      std::string str;
+      StringCell *link;
+   };
+
+   enum NumberScannerState {
+      INITIAL_STATE,
+      BEFORE_DECIMAL_POINT,
+      AFTER_DECIMAL_POINT,
+      STARTING_EXPONENT,
+      FOUND_EXPONENT_SIGN,
+      SCANNING_EXPONENT,
+      FINAL_STATE
+   };
+
+   std::string buffer;              /* The original argument string */
+   std::istream *isp;               /* The input stream for tokens  */
+   bool stringInputFlag;            /* Flag indicating string input */
+   bool ignoreWhitespaceFlag;       /* Scanner ignores whitespace   */
+   bool ignoreCommentsFlag;         /* Scanner ignores comments     */
+   bool scanNumbersFlag;            /* Scanner parses numbers       */
+   bool scanStringsFlag;            /* Scanner parses strings       */
+   std::string wordChars;           /* Additional word characters   */
+   StringCell *savedTokens;         /* Stack of saved tokens        */
+   StringCell *operators;           /* List of multichar operators  */
+
+/* Private method prototypes */
+
+   void initScanner();
+   void skipSpaces();
+   std::string scanWord();
+   std::string scanNumber();
+   std::string scanString();
+   bool isOperator(std::string op);
+   bool isOperatorPrefix(std::string op);
+
+};
+
+#endif
diff --git a/labb8/lib/StanfordCPPLib/vector.h b/labb8/lib/StanfordCPPLib/vector.h
new file mode 100755
index 0000000..9781daa
--- /dev/null
+++ b/labb8/lib/StanfordCPPLib/vector.h
@@ -0,0 +1,727 @@
+/*
+ * File: vector.h
+ * --------------
+ * This file exports the <code>Vector</code> class, which provides an
+ * efficient, safe, convenient replacement for the array type in C++.
+ */
+
+#ifndef _vector_h
+#define _vector_h
+
+#include <iterator>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include "foreach.h"
+#include "strlib.h"
+
+/*
+ * Class: Vector<ValueType>
+ * ------------------------
+ * This class stores an ordered list of values similar to an array.
+ * It supports traditional array selection using square brackets, but
+ * also supports inserting and deleting elements.  It is similar in
+ * function to the STL <code>vector</code> type, but is simpler both
+ * to use and to implement.
+ */
+
+template <typename ValueType>
+class Vector {
+
+public:
+
+/*
+ * Constructor: Vector
+ * Usage: Vector<ValueType> vec;
+ *        Vector<ValueType> vec(n, value);
+ * ---------------------------------------
+ * Initializes a new vector.  The default constructor creates an
+ * empty vector.  The second form creates an array with <code>n</code>
+ * elements, each of which is initialized to <code>value</code>;
+ * if <code>value</code> is missing, the elements are initialized
+ * to the default value for the type.
+ */
+
+   Vector();
+   explicit Vector(int n, ValueType value = ValueType());
+
+/*
+ * Destructor: ~Vector
+ * -------------------
+ * Frees any heap storage allocated by this vector.
+ */
+
+   virtual ~Vector();
+
+/*
+ * Method: size
+ * Usage: int nElems = vec.size();
+ * -------------------------------
+ * Returns the number of elements in this vector.
+ */
+
+   int size() const;
+
+/*
+ * Method: isEmpty
+ * Usage: if (vec.isEmpty()) ...
+ * -----------------------------
+ * Returns <code>true</code> if this vector contains no elements.
+ */
+
+   bool isEmpty() const;
+
+/*
+ * Method: clear
+ * Usage: vec.clear();
+ * -------------------
+ * Removes all elements from this vector.
+ */
+
+   void clear();
+
+/*
+ * Method: get
+ * Usage: ValueType val = vec.get(index);
+ * --------------------------------------
+ * Returns the element at the specified index in this vector.  This
+ * method signals an error if the index is not in the array range.
+ */
+
+   const ValueType & get(int index) const;
+
+/*
+ * Method: set
+ * Usage: vec.set(index, value);
+ * -----------------------------
+ * Replaces the element at the specified index in this vector with
+ * a new value.  The previous value at that index is overwritten.
+ * This method signals an error if the index is not in the array range.
+ */
+
+   void set(int index, const ValueType & value);
+
+/*
+ * Method: insert
+ * Usage: vec.insert(0, value);
+ * ----------------------------
+ * Inserts the element into this vector before the specified index.
+ * All subsequent elements are shifted one position to the right.  This
+ * method signals an error if the index is outside the range from 0
+ * up to and including the length of the vector.
+ */
+
+   void insert(int index, ValueType value);
+
+/*
+ * Method: remove
+ * Usage: vec.remove(index);
+ * -------------------------
+ * Removes the element at the specified index from this vector.
+ * All subsequent elements are shifted one position to the left.  This
+ * method signals an error if the index is outside the array range.
+ */
+
+   void remove(int index);
+
+/*
+ * Method: add
+ * Usage: vec.add(value);
+ * ----------------------
+ * Adds a new value to the end of this vector.  To ensure compatibility
+ * with the <code>vector</code> class in the Standard Template Library,
+ * this method is also called <code>push_back</code>.
+ */
+
+   void add(ValueType value);
+   void push_back(ValueType value);
+
+/*
+ * Operator: []
+ * Usage: vec[index]
+ * -----------------
+ * Overloads <code>[]</code> to select elements from this vector.
+ * This extension enables the use of traditional array notation to
+ * get or set individual elements.  This method signals an error if
+ * the index is outside the array range.  The file supports two
+ * versions of this operator, one for <code>const</code> vectors and
+ * one for mutable vectors.
+ */
+
+   ValueType & operator[](int index);
+   const ValueType & operator[](int index) const;
+
+/*
+ * Operator: +
+ * Usage: v1 + v2
+ * --------------
+ * Concatenates two vectors.
+ */
+
+   Vector operator+(const Vector & v2) const;
+
+/*
+ * Operator: +=
+ * Usage: v1 += v2;
+ *        v1 += value;
+ * -------------------
+ * Adds all of the elements from <code>v2</code> (or the single
+ * specified value) to <code>v1</code>.  As a convenience, the
+ * <code>Vector</code> package also overloads the comma operator so
+ * that it is possible to initialize a vector like this:
+ *
+ *<pre>
+ *    Vector&lt;int&gt; digits;
+ *    digits += 0, 1, 2, 3, 4, 5, 6, 7, 8, 9;
+ *</pre>
+ */
+
+   Vector & operator+=(const Vector & v2);
+   Vector & operator+=(const ValueType & value);
+
+   bool operator==(const Vector & v2);
+   bool operator!=(const Vector & v2);
+
+/*
+ * Method: toString
+ * Usage: string str = vec.toString();
+ * -----------------------------------
+ * Converts the vector to a printable string representation.
+ */
+
+   std::string toString();
+
+/*
+ * Method: mapAll
+ * Usage: vec.mapAll(fn);
+ * ----------------------
+ * Calls the specified function on each element of the vector in
+ * ascending index order.
+ */
+
+   void mapAll(void (*fn)(ValueType)) const;
+   void mapAll(void (*fn)(const ValueType &)) const;
+
+   template <typename FunctorType>
+   void mapAll(FunctorType fn) const;
+
+/*
+ * Additional Vector operations
+ * ----------------------------
+ * In addition to the methods listed in this interface, the Vector
+ * class supports the following operations:
+ *
+ *   - Stream I/O using the << and >> operators
+ *   - Deep copying for the copy constructor and assignment operator
+ *   - Iteration using the range-based for statement or STL iterators
+ *
+ * The iteration forms process the Vector in index order.
+ */
+
+/* Private section */
+
+/**********************************************************************/
+/* Note: Everything below this point in the file is logically part    */
+/* of the implementation and should not be of interest to clients.    */
+/**********************************************************************/
+
+private:
+
+/*
+ * Implementation notes: Vector data structure
+ * -------------------------------------------
+ * The elements of the Vector are stored in a dynamic array of
+ * the specified element type.  If the space in the array is ever
+ * exhausted, the implementation doubles the array capacity.
+ */
+
+/* Instance variables */
+
+   ValueType *elements;        /* A dynamic array of the elements   */
+   int capacity;               /* The allocated size of the array   */
+   int count;                  /* The number of elements in use     */
+
+/* Private methods */
+
+   void expandCapacity();
+   void deepCopy(const Vector & src);
+
+/*
+ * Hidden features
+ * ---------------
+ * The remainder of this file consists of the code required to
+ * support deep copying and iteration.  Including these methods
+ * in the public interface would make that interface more
+ * difficult to understand for the average client.
+ */
+
+public:
+
+/*
+ * Deep copying support
+ * --------------------
+ * This copy constructor and operator= are defined to make a deep copy,
+ * making it possible to pass or return vectors by value and assign
+ * from one vector to another.
+ */
+
+   Vector(const Vector & src);
+   Vector & operator=(const Vector & src);
+
+/*
+ * Operator: ,
+ * -----------
+ * Adds an element to the vector passed as the left-hand operatand.
+ * This form makes it easier to initialize vectors in old versions of C++.
+ */
+
+   Vector & operator,(const ValueType & value);
+
+/*
+ * Iterator support
+ * ----------------
+ * The classes in the StanfordCPPLib collection implement input
+ * iterators so that they work symmetrically with respect to the
+ * corresponding STL classes.
+ */
+
+   class iterator :
+      public std::iterator<std::random_access_iterator_tag, ValueType> {
+
+   private:
+      const Vector *vp;
+      int index;
+
+   public:
+
+      iterator() {
+         this->vp = NULL;
+      }
+
+      iterator(const iterator & it) {
+         this->vp = it.vp;
+         this->index = it.index;
+      }
+
+      iterator(const Vector *vp, int index) {
+         this->vp = vp;
+         this->index = index;
+      }
+
+      iterator & operator++() {
+         index++;
+         return *this;
+      }
+
+      iterator operator++(int) {
+         iterator copy(*this);
+         operator++();
+         return copy;
+      }
+
+      iterator & operator--() {
+         index--;
+         return *this;
+      }
+
+      iterator operator--(int) {
+         iterator copy(*this);
+         operator--();
+         return copy;
+      }
+
+      bool operator==(const iterator & rhs) {
+         return vp == rhs.vp && index == rhs.index;
+      }
+
+      bool operator!=(const iterator & rhs) {
+         return !(*this == rhs);
+      }
+
+      bool operator<(const iterator & rhs) {
+         extern void error(std::string msg);
+         if (vp != rhs.vp) error("Iterators are in different vectors");
+         return index < rhs.index;
+      }
+
+      bool operator<=(const iterator & rhs) {
+         extern void error(std::string msg);
+         if (vp != rhs.vp) error("Iterators are in different vectors");
+         return index <= rhs.index;
+      }
+
+      bool operator>(const iterator & rhs) {
+         extern void error(std::string msg);
+         if (vp != rhs.vp) error("Iterators are in different vectors");
+         return index > rhs.index;
+      }
+
+      bool operator>=(const iterator & rhs) {
+         extern void error(std::string msg);
+         if (vp != rhs.vp) error("Iterators are in different vectors");
+         return index >= rhs.index;
+      }
+
+      iterator operator+(const int & rhs) {
+         return iterator(vp, index + rhs);
+      }
+
+      iterator operator+=(const int & rhs) {
+         index += rhs;
+         return *this;
+      }
+
+      iterator operator-(const int & rhs) {
+         return iterator(vp, index - rhs);
+      }
+
+      iterator operator-=(const int & rhs) {
+         index -= rhs;
+         return *this;
+      }
+
+      int operator-(const iterator & rhs) {
+         extern void error(std::string msg);
+         if (vp != rhs.vp) error("Iterators are in different vectors");
+         return index - rhs.index;
+      }
+
+      ValueType & operator*() {
+         return vp->elements[index];
+      }
+
+      ValueType *operator->() {
+         return &vp->elements[index];
+      }
+
+      ValueType & operator[](int k) {
+         return vp->elements[index + k];
+      }
+
+   };
+
+   iterator begin() const {
+      return iterator(this, 0);
+   }
+
+   iterator end() const {
+      return iterator(this, count);
+   }
+
+};
+
+/* Implementation section */
+
+extern void error(std::string msg);
+
+/*
+ * Implementation notes: Vector constructor and destructor
+ * -------------------------------------------------------
+ * The constructor allocates storage for the dynamic array
+ * and initializes the other fields of the object.  The
+ * destructor frees the memory used for the array.
+ */
+
+template <typename ValueType>
+Vector<ValueType>::Vector() {
+   count = capacity = 0;
+   elements = NULL;
+}
+
+template <typename ValueType>
+Vector<ValueType>::Vector(int n, ValueType value) {
+   count = capacity = n;
+   elements = (n == 0) ? NULL : new ValueType[n];
+   for (int i = 0; i < n; i++) {
+      elements[i] = value;
+   }
+}
+
+template <typename ValueType>
+Vector<ValueType>::~Vector() {
+   if (elements != NULL) delete[] elements;
+}
+
+/*
+ * Implementation notes: Vector methods
+ * ------------------------------------
+ * The basic Vector methods are straightforward and should require
+ * no detailed documentation.
+ */
+
+template <typename ValueType>
+int Vector<ValueType>::size() const {
+   return count;
+}
+
+template <typename ValueType>
+bool Vector<ValueType>::isEmpty() const {
+   return count == 0;
+}
+
+template <typename ValueType>
+void Vector<ValueType>::clear() {
+   if (elements != NULL) delete[] elements;
+   count = capacity = 0;
+   elements = NULL;
+}
+
+template <typename ValueType>
+const ValueType & Vector<ValueType>::get(int index) const {
+   if (index < 0 || index >= count) error("get: index out of range");
+   return elements[index];
+}
+
+template <typename ValueType>
+void Vector<ValueType>::set(int index, const ValueType & value) {
+   if (index < 0 || index >= count) error("set: index out of range");
+   elements[index] = value;
+}
+
+/*
+ * Implementation notes: insert, remove, add
+ * -----------------------------------------
+ * These methods must shift the existing elements in the array to
+ * make room for a new element or to close up the space left by a
+ * deleted one.
+ */
+
+template <typename ValueType>
+void Vector<ValueType>::insert(int index, ValueType value) {
+   if (count == capacity) expandCapacity();
+   if (index < 0 || index > count) {
+      error("insert: index out of range");
+   }
+   for (int i = count; i > index; i--) {
+      elements[i] = elements[i - 1];
+   }
+   elements[index] = value;
+   count++;
+}
+
+template <typename ValueType>
+void Vector<ValueType>::remove(int index) {
+   if (index < 0 || index >= count) error("remove: index out of range");
+   for (int i = index; i < count - 1; i++) {
+      elements[i] = elements[i + 1];
+   }
+   count--;
+}
+
+template <typename ValueType>
+void Vector<ValueType>::add(ValueType value) {
+   insert(count, value);
+}
+
+template <typename ValueType>
+void Vector<ValueType>::push_back(ValueType value) {
+   insert(count, value);
+}
+
+/*
+ * Implementation notes: Vector selection
+ * --------------------------------------
+ * The following code implements traditional array selection using
+ * square brackets for the index.
+ */
+
+template <typename ValueType>
+ValueType & Vector<ValueType>::operator[](int index) {
+   if (index < 0 || index >= count) error("Selection index out of range");
+   return elements[index];
+}
+template <typename ValueType>
+const ValueType & Vector<ValueType>::operator[](int index) const {
+   if (index < 0 || index >= count) error("Selection index out of range");
+   return elements[index];
+}
+
+template <typename ValueType>
+Vector<ValueType> Vector<ValueType>::operator+(const Vector & v2) const {
+   Vector<ValueType> vec = *this;
+   foreach (ValueType value in v2) {
+      vec.add(value);
+   }
+   return vec;
+}
+
+template <typename ValueType>
+Vector<ValueType> & Vector<ValueType>::operator+=(const Vector & v2) {
+   foreach (ValueType value in v2) {
+      *this += value;
+   }
+   return *this;
+}
+
+template <typename ValueType>
+Vector<ValueType> & Vector<ValueType>::operator+=(const ValueType & value) {
+   this->add(value);
+   return *this;
+}
+
+template <typename ValueType>
+bool Vector<ValueType>::operator==(const Vector & v2) {
+    if (this->size() != v2.size()) {
+        return false;
+    }
+    for (int i = 0, size = this->size(); i < size; i++) {
+        if (this->get(i) != v2.get(i)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+template <typename ValueType>
+bool Vector<ValueType>::operator!=(const Vector & v2) {
+    return !(*this == v2);
+}
+
+template <typename ValueType>
+std::string Vector<ValueType>::toString() {
+   ostringstream os;
+   os << *this;
+   return os.str();
+}
+
+/*
+ * Implementation notes: copy constructor and assignment operator
+ * --------------------------------------------------------------
+ * The constructor and assignment operators follow a standard paradigm,
+ * as described in the associated textbook.
+ */
+
+template <typename ValueType>
+Vector<ValueType>::Vector(const Vector & src) {
+   deepCopy(src);
+}
+
+template <typename ValueType>
+Vector<ValueType> & Vector<ValueType>::operator=(const Vector & src) {
+   if (this != &src) {
+      if (elements != NULL) delete[] elements;
+      deepCopy(src);
+   }
+   return *this;
+}
+
+template <typename ValueType>
+void Vector<ValueType>::deepCopy(const Vector & src) {
+   count = capacity = src.count;
+   elements = (capacity == 0) ? NULL : new ValueType[capacity];
+   for (int i = 0; i < count; i++) {
+      elements[i] = src.elements[i];
+   }
+}
+
+/*
+ * Implementation notes: The , operator
+ * ------------------------------------
+ * The comma operator works adding the right operand to the vector and
+ * then returning the vector by reference so that it is set for the next
+ * value in the chain.
+ */
+
+template <typename ValueType>
+Vector<ValueType> & Vector<ValueType>::operator,(const ValueType & value) {
+   this->add(value);
+   return *this;
+}
+
+/*
+ * Implementation notes: mapAll
+ * ----------------------------
+ * The various versions of the mapAll function apply the function or
+ * function object to each element in ascending index order.
+ */
+
+template <typename ValueType>
+void Vector<ValueType>::mapAll(void (*fn)(ValueType)) const {
+   for (int i = 0; i < count; i++) {
+      fn(elements[i]);
+   }
+}
+
+template <typename ValueType>
+void Vector<ValueType>::mapAll(void (*fn)(const ValueType &)) const {
+   for (int i = 0; i < count; i++) {
+      fn(elements[i]);
+   }
+}
+
+template <typename ValueType>
+template <typename FunctorType>
+void Vector<ValueType>::mapAll(FunctorType fn) const {
+   for (int i = 0; i < count; i++) {
+      fn(elements[i]);
+   }
+}
+
+/*
+ * Implementation notes: expandCapacity
+ * ------------------------------------
+ * This function doubles the array capacity, copies the old elements
+ * into the new array, and then frees the old one.
+ */
+
+template <typename ValueType>
+void Vector<ValueType>::expandCapacity() {
+   capacity = max(1, capacity * 2);
+   ValueType *array = new ValueType[capacity];
+   for (int i = 0; i < count; i++) {
+      array[i] = elements[i];
+   }
+   if (elements != NULL) delete[] elements;
+   elements = array;
+}
+
+/*
+ * Implementation notes: << and >>
+ * -------------------------------
+ * The insertion and extraction operators use the template facilities in
+ * strlib.h to read and write generic values in a way that treats strings
+ * specially.
+ */
+
+template <typename ValueType>
+std::ostream & operator<<(std::ostream & os, const Vector<ValueType> & vec) {
+   os << "{";
+   int len = vec.size();
+   for (int i = 0; i < len; i++) {
+      if (i > 0) os << ", ";
+      writeGenericValue(os, vec[i], true);
+   }
+   return os << "}";
+}
+
+template <typename ValueType>
+std::istream & operator>>(std::istream & is, Vector<ValueType> & vec) {
+   char ch;
+   is >> ch;
+   if (ch != '{') error("operator >>: Missing {");
+   vec.clear();
+   is >> ch;
+   if (ch != '}') {
+      is.unget();
+      while (true) {
+         ValueType value;
+         readGenericValue(is, value);
+         vec += value;
+         is >> ch;
+         if (ch == '}') break;
+         if (ch != ',') {
+            error(std::string("operator >>: Unexpected character ") + ch);
+         }
+      }
+   }
+   return is;
+}
+
+// hashing functions for vectors;  defined in hashmap.cpp
+int hashCode(const Vector<std::string>& v);
+int hashCode(const Vector<int>& v);
+int hashCode(const Vector<char>& v);
+int hashCode(const Vector<long>& v);
+int hashCode(const Vector<double>& v);
+
+#endif
diff --git a/labb8/lib/readme.txt b/labb8/lib/readme.txt
new file mode 100755
index 0000000..9d0d5c8
--- /dev/null
+++ b/labb8/lib/readme.txt
@@ -0,0 +1,4 @@
+This directory contains any libraries that should be

+linked to your project when it is built.

+The most common library we will link to is the

+Stanford C++ library (cpplib).

diff --git a/labb8/lib/spl.jar b/labb8/lib/spl.jar
new file mode 100755
index 0000000..3cdc64f
--- /dev/null
+++ b/labb8/lib/spl.jar