diff --git a/src/.DS_Store b/src/.DS_Store
new file mode 100644
index 0000000..6e3d302
Binary files /dev/null and b/src/.DS_Store differ
diff --git a/src/12cards0setsMilestone.dat b/src/12cards0setsMilestone.dat
new file mode 100755
index 0000000..dc7c2c6
--- /dev/null
+++ b/src/12cards0setsMilestone.dat
@@ -0,0 +1,13 @@
+# 12 cards with 0 sets
+1 3 3 2 
+3 3 2 2 
+1 1 2 1 
+1 2 3 3 
+3 2 3 3 
+1 3 1 3 
+3 1 2 2 
+2 2 3 2 
+1 1 1 1 
+3 2 1 1 
+2 1 1 3 
+2 2 1 3
diff --git a/src/12cards14setsMilestone.dat b/src/12cards14setsMilestone.dat
new file mode 100755
index 0000000..1b3ea71
--- /dev/null
+++ b/src/12cards14setsMilestone.dat
@@ -0,0 +1,12 @@
+1 1 1 1
+1 1 1 2
+1 1 1 3
+1 1 2 1
+1 1 2 2
+1 1 2 3
+1 1 3 1
+1 1 3 2
+1 1 3 3
+1 2 1 1
+1 3 1 1
+1 2 1 2
diff --git a/src/3cards.txt b/src/3cards.txt
new file mode 100755
index 0000000..3c2b949
--- /dev/null
+++ b/src/3cards.txt
@@ -0,0 +1,4 @@
+#3cards
+1 1 1 1
+1 1 1 2
+1 1 1 3
\ No newline at end of file
diff --git a/src/3cards0setsMilestone.dat b/src/3cards0setsMilestone.dat
new file mode 100644
index 0000000..b0a41dc
--- /dev/null
+++ b/src/3cards0setsMilestone.dat
@@ -0,0 +1,12 @@
+# Lines starting with a # character are comments, and ignored
+# Blank lines are also ignored, even if they contain whitespace
+   
+# All other lines are expected to have 4 integers, separated by spaces
+1 1 1 1
+1 1 1 2
+2 2 2 3
+
+# A file does not need to contain all 81 cards
+
+  
+  
diff --git a/src/3cards1setMilestone.dat b/src/3cards1setMilestone.dat
new file mode 100755
index 0000000..3fdd6d1
--- /dev/null
+++ b/src/3cards1setMilestone.dat
@@ -0,0 +1,3 @@
+1 1 1 1
+2 2 2 2
+3 3 3 3
diff --git a/src/81cards.txt b/src/81cards.txt
new file mode 100644
index 0000000..9e0b11b
--- /dev/null
+++ b/src/81cards.txt
@@ -0,0 +1,81 @@
+1 1 1 1
+1 1 1 2
+1 1 1 3
+1 1 2 1
+1 1 2 2
+1 1 2 3
+1 1 3 1
+1 1 3 2
+1 1 3 3
+1 2 1 1
+1 2 1 2
+1 2 1 3
+1 2 2 1
+1 2 2 2
+1 2 2 3
+1 2 3 1
+1 2 3 2
+1 2 3 3
+1 3 1 1
+1 3 1 2
+1 3 1 3
+1 3 2 1
+1 3 2 2
+1 3 2 3
+1 3 3 1
+1 3 3 2
+1 3 3 3
+2 1 1 1
+2 1 1 2
+2 1 1 3
+2 1 2 1
+2 1 2 2
+2 1 2 3
+2 1 3 1
+2 1 3 2
+2 1 3 3
+2 2 1 1
+2 2 1 2
+2 2 1 3
+2 2 2 1
+2 2 2 2
+2 2 2 3
+2 2 3 1
+2 2 3 2
+2 2 3 3
+2 3 1 1
+2 3 1 2
+2 3 1 3
+2 3 2 1
+2 3 2 2
+2 3 2 3
+2 3 3 1
+2 3 3 2
+2 3 3 3
+3 1 1 1
+3 1 1 2
+3 1 1 3
+3 1 2 1
+3 1 2 2
+3 1 2 3
+3 1 3 1
+3 1 3 2
+3 1 3 3
+3 2 1 1
+3 2 1 2
+3 2 1 3
+3 2 2 1
+3 2 2 2
+3 2 2 3
+3 2 3 1
+3 2 3 2
+3 2 3 3
+3 3 1 1
+3 3 1 2
+3 3 1 3
+3 3 2 1
+3 3 2 2
+3 3 2 3
+3 3 3 1
+3 3 3 2
+3 3 3 3
\ No newline at end of file
diff --git a/src/Card.class b/src/Card.class
new file mode 100644
index 0000000..8f20a97
Binary files /dev/null and b/src/Card.class differ
diff --git a/src/Card.java b/src/Card.java
old mode 100755
new mode 100644
index 9eed9a5..c2ac76c
--- a/src/Card.java
+++ b/src/Card.java
@@ -1,5 +1,114 @@
-public class Card {
-  // Create the rest of this class yourself
+public class Card{
+  
+  private int quantity;
+  private int color;
+  private int shading;
+  private int shape;
+  
+  private String quan;
+  private String col;
+  private String shad;
+  private String shap;
+  
+  public Card(int cardQuantity, int cardColor, int cardShading, int cardShape) {
+    if (cardQuantity < 1 || cardQuantity > 3) {
+      quantity = (((cardQuantity % 3) + 3) % 3) + 1;
+    }
+    else {
+      quantity = cardQuantity;
+    }
+    if (cardColor < 1 || cardColor > 3) {
+      color = (((cardColor % 3) + 3) % 3) + 1;
+    }
+    else {
+      color = cardColor;
+    }
+    if (cardShading < 1 || cardShading > 3) {
+      shading = (((cardShading % 3) + 3) % 3)  + 1;
+    }
+    else {
+      shading = cardShading;
+    }
+    if (cardShape < 1 || cardShape > 3) {
+      shape = (((cardShape % 3) + 3) % 3)  + 1;
+    }
+    else {
+      shape = cardShape;
+    }
+  }
+  
+  public int getQuantity() {
+    return quantity;
+  }
+  
+  public int getColor() {
+    return color;
+  }
+  
+  public int getShading() {
+    return shading;
+  }
+  
+  public int getShape() {
+    return shape;
+  }
+  
+  public boolean isSet(Card two, Card three) {
+    
+    int totalQuantity = getQuantity() + two.getQuantity() + three.getQuantity();
+    int totalColor = getColor() + two.getColor() + three.getColor();
+    int totalShading = getShading() + two.getShading() + three.getShading();
+    int totalShape = getShape() + two.getShape() + three.getShape();
+    
+    if (totalQuantity % 3 == 0 && totalColor % 3 == 0 && totalShading % 3 == 0 && totalShape % 3 == 0) {
+      return true;
+    }
+    else {
+      return false;
+    }
+  }
+  
+  public String toString() {
+    
+    if (quantity == 1) {
+      quan = ("1");
+    }
+    else if (quantity == 2) {
+      quan = ("2");
+    }
+    else { // (quantity == 3)
+      quan = ("3");
+    }
+    if (color == 1) {
+      col = ("R"); //red
+    }
+    else if (color == 2) {
+      col = ("G"); //green
+    }
+    else{ //(color == 3)
+      col = ("P"); //purple
+    }
+     if (shading == 1) {
+      shad = ("O"); //empty
+    }
+    else if (shading == 2) {
+      shad = ("T"); //striped/shaded
+    }
+    else{ // (shading == 3)
+      shad = ("S"); //solid/filled
+    }
+    if (shape == 1) {
+      shap = ("O"); //oval
+    }
+    else if (shape == 2) {
+      shap = ("D"); //diamond
+    }
+    else{ // (shading == 3)
+      shap = ("S"); //squiggle
+    }
+    String sequence = quan + col + shad + shap;
+    return sequence;
+  }
   
   public boolean equals(Object obj) {
     Card that = (Card)obj;
@@ -9,4 +118,5 @@ public boolean equals(Object obj) {
       shading == that.getShading() &&
       shape == that.getShape();
   }
+  
 }
diff --git a/src/CardMain.class b/src/CardMain.class
new file mode 100644
index 0000000..c6450c2
Binary files /dev/null and b/src/CardMain.class differ
diff --git a/src/CardMain.java b/src/CardMain.java
new file mode 100644
index 0000000..c64622d
--- /dev/null
+++ b/src/CardMain.java
@@ -0,0 +1,14 @@
+public class CardMain{
+  public static void main(String[] args){
+
+    Game g = new Game("81cards.txt");
+    System.out.println(g.numCards());
+    System.out.println(g.numSets());
+    g.playRound();
+    System.out.println(g.numSets());
+    System.out.println(g.numCards());
+  }
+}
+
+
+
diff --git a/src/CardTest.class b/src/CardTest.class
new file mode 100644
index 0000000..0f33998
Binary files /dev/null and b/src/CardTest.class differ
diff --git a/src/CardTest.java b/src/CardTest.java
new file mode 100644
index 0000000..6716a36
--- /dev/null
+++ b/src/CardTest.java
@@ -0,0 +1,193 @@
+import junit.framework.TestCase;
+
+/**
+ * A JUnit test case class.
+ * Every method starting with the word "test" will be called when running
+ * the test with JUnit.
+ */
+public class CardTest extends TestCase {
+  
+  /**
+   * A test method.
+   * (Replace "X" with a name describing the test.  You may write as
+   * many "testSomething" methods in this class as you wish, and each
+   * one will be called when running JUnit over this class.)
+   */
+  public void test123()
+  {
+    //testing when everything is different
+    Card card1 = new Card(1, 1, 1, 1);
+    assertEquals(card1.getQuantity(), 1);
+    assertEquals(card1.getColor(), 1);
+    assertEquals(card1.getShading(), 1);
+    assertEquals(card1.getShape(), 1);
+    assertEquals(card1.toString(), "1ROO");
+    Card card2 = new Card(2, 2, 2, 2);
+    assertEquals(card2.getQuantity(), 2);
+    assertEquals(card2.getColor(), 2);
+    assertEquals(card2.getShading(), 2);
+    assertEquals(card2.getShape(), 2);
+    assertEquals(card2.toString(), "2GTD");
+    Card card3 = new Card(3, 3, 3, 3);
+    assertEquals(card3.getQuantity(), 3);
+    assertEquals(card3.getColor(), 3);
+    assertEquals(card3.getShading(), 3);
+    assertEquals(card3.getShape(), 3);
+    assertEquals(card3.toString(), "3PSS");
+    assertEquals(card1.isSet(card2, card3), true);
+  }
+  public void testStupidNumbers()
+  {
+    //testing when all shading is different
+    Card negCard = new Card(-3, -33, -333, -3333);
+    assertEquals(negCard.getQuantity(), 1);
+    assertEquals(negCard.getColor(), 1);
+    assertEquals(negCard.getShading(), 1);
+    assertEquals(negCard.getShape(), 1);
+    assertEquals(negCard.toString(), "1ROO");
+    Card lrgCard = new Card(2147483647, 172831, 7910, 457);
+    assertEquals(lrgCard.getQuantity(), 2);
+    assertEquals(lrgCard.getColor(), 2);
+    assertEquals(lrgCard.getShading(), 3);
+    assertEquals(lrgCard.getShape(), 2);
+    assertEquals(lrgCard.toString(), "2GSD");
+    Card ranCard = new Card(24, 0, -2147483648, 2);
+    assertEquals(ranCard.getQuantity(), 1);
+    assertEquals(ranCard.getColor(), 1);
+    assertEquals(ranCard.getShading(), 2);
+    assertEquals(ranCard.getShape(), 2);
+    assertEquals(ranCard.toString(), "1RTD"); 
+    assertEquals(negCard.isSet(lrgCard, ranCard), false);
+  }
+  
+  public void test3()
+  {
+    //testing when all the same
+    Card card4 = new Card(3, 3, 3, 3);
+    assertEquals(card4.getQuantity(), 3);
+    assertEquals(card4.getColor(), 3);
+    assertEquals(card4.getShading(), 3);
+    assertEquals(card4.getShape(), 3);
+    assertEquals(card4.toString(), "3PSS");
+    Card card5 = new Card(3,3,3,3);
+    assertEquals(card5.getQuantity(), 3);
+    assertEquals(card5.getColor(), 3);
+    assertEquals(card5.getShading(), 3);
+    assertEquals(card5.getShape(), 3);
+    assertEquals(card5.toString(), "3PSS");
+    Card card6 = new Card(3,3,3,3);
+    assertEquals(card6.getQuantity(), 3);
+    assertEquals(card6.getColor(), 3);
+    assertEquals(card6.getShading(), 3);
+    assertEquals(card6.getShape(), 3);
+    assertEquals(card6.toString(), "3PSS");
+    assertEquals(card4.isSet(card5, card6), true);
+  }
+  
+  public void test2()
+  {
+    Card card1 = new Card(2, 2, 2, 2);
+    assertEquals(card1.getQuantity(), 2);
+    assertEquals(card1.getColor(), 2);
+    assertEquals(card1.getShading(), 2);
+    assertEquals(card1.getShape(), 2);
+    assertEquals(card1.toString(), "2GTD");
+    Card card2 = new Card(2, 2, 2, 2);
+    assertEquals(card2.getQuantity(), 2);
+    assertEquals(card2.getColor(), 2);
+    assertEquals(card2.getShading(), 2);
+    assertEquals(card2.getShape(), 2);
+    assertEquals(card2.toString(), "2GTD");
+    Card card3 = new Card(2, 2, 2, 2);
+    assertEquals(card3.getQuantity(), 2);
+    assertEquals(card3.getColor(), 2);
+    assertEquals(card3.getShading(), 2);
+    assertEquals(card3.getShape(), 2);
+    assertEquals(card3.toString(), "2GTD");
+    assertEquals(card1.isSet(card2, card3), true);
+  }
+  
+  public void test1()
+  {
+    Card card1 = new Card(1, 1, 1, 1);
+    assertEquals(card1.getQuantity(), 1);
+    assertEquals(card1.getColor(), 1);
+    assertEquals(card1.getShading(), 1);
+    assertEquals(card1.getShape(), 1);
+    assertEquals(card1.toString(), "1ROO");
+    Card card2 = new Card(1, 1, 1, 1);
+    assertEquals(card2.getQuantity(), 1);
+    assertEquals(card2.getColor(), 1);
+    assertEquals(card2.getShading(), 1);
+    assertEquals(card2.getShape(), 1);
+    assertEquals(card2.toString(), "1ROO");
+    Card card3 = new Card(1, 1, 1, 1);
+    assertEquals(card3.getQuantity(), 1);
+    assertEquals(card3.getColor(), 1);
+    assertEquals(card3.getShading(), 1);
+    assertEquals(card3.getShape(), 1);
+    assertEquals(card3.toString(), "1ROO");
+    assertEquals(card1.isSet(card2, card3), true);
+  }
+  
+  public void testAgainWheeee()
+  {
+    Card card1 = new Card(3, 3, 1, 2);
+    assertEquals(card1.getQuantity(), 3);
+    assertEquals(card1.getColor(), 3);
+    assertEquals(card1.getShading(), 1);
+    assertEquals(card1.getShape(), 2);
+    assertEquals(card1.toString(), "3POD");
+    Card card2 = new Card(1, 2, 3, 3);
+    assertEquals(card2.getQuantity(), 1);
+    assertEquals(card2.getColor(), 2);
+    assertEquals(card2.getShading(), 3);
+    assertEquals(card2.getShape(), 3);
+    assertEquals(card2.toString(), "1GSS");
+    Card card3 = new Card(2, 1, 2, 1);
+    assertEquals(card3.getQuantity(), 2);
+    assertEquals(card3.getColor(), 1);
+    assertEquals(card3.getShading(), 2);
+    assertEquals(card3.getShape(), 1);
+    assertEquals(card3.toString(), "2RTO");
+    assertEquals(card1.isSet(card2, card3), true);
+  }
+  
+  public void testAgainAgain()
+  {
+    Card card1 = new Card(3, 3, 1, 23);
+    assertEquals(card1.getQuantity(), 3);
+    assertEquals(card1.getColor(), 3);
+    assertEquals(card1.getShading(), 1);
+    assertEquals(card1.getShape(), 3);
+    assertEquals(card1.toString(), "3POS");
+    Card card2 = new Card(1, 2, 3, 3);
+    assertEquals(card2.getQuantity(), 1);
+    assertEquals(card2.getColor(), 2);
+    assertEquals(card2.getShading(), 3);
+    assertEquals(card2.getShape(), 3);
+    assertEquals(card2.toString(), "1GSS");
+    Card card3 = new Card(2, 1, 2, 1);
+    assertEquals(card3.getQuantity(), 2);
+    assertEquals(card3.getColor(), 1);
+    assertEquals(card3.getShading(), 2);
+    assertEquals(card3.getShape(), 1);
+    assertEquals(card3.toString(), "2RTO");
+    assertEquals(card1.isSet(card2, card3), false);
+  }
+  
+  public void testEqualsMethod()
+  {
+    Card card1 = new Card(1, 1, 1, 1);
+    Card card2 = new Card(1, 1, 1, 1);
+    Card card3 = new Card(2, 2, 2, 2);
+    
+    assertTrue(card1.equals(card2));
+    assertTrue(card2.equals(card1));
+    assertFalse(card1.equals(card3));
+    assertFalse(card3.equals(card1));   
+    assertFalse(card2.equals(card3));
+    assertFalse(card3.equals(card2));
+  }
+  
+}
\ No newline at end of file
diff --git a/src/Deck.class b/src/Deck.class
new file mode 100644
index 0000000..cc8e77d
Binary files /dev/null and b/src/Deck.class differ
diff --git a/src/Deck.java b/src/Deck.java
old mode 100755
new mode 100644
index ab3a2a3..1fb35be
--- a/src/Deck.java
+++ b/src/Deck.java
@@ -1,13 +1,55 @@
+import java.util.Collections;
 import java.io.BufferedReader;
 import java.io.FileReader;
 import java.util.StringTokenizer;
 import java.util.ArrayList;
 
+
 public class Deck {
-  // Implement the rest of this class yourself
+  private int nextCardIndex = 0;
+  private ArrayList<Card> cards = new ArrayList<Card>(81);
+  
+  public Deck(){
+    for (int i=1; i<=3; i++) {
+      for (int j=1; j<=3; j++) {
+        for (int k=1; k<=3; k++) {
+          for (int m=1; m<=3; m++) {
+            Card card = new Card(i, j, k, m);
+            cards.add(card);
+          }
+        }
+      }
+    }
+    Collections.shuffle(cards);  
+  }
+  
+  public int getSize(){
+    return cards.size();
+  }
+  
+  public boolean hasNext() {
+    if (nextCardIndex < cards.size()) {
+      return true;
+    }
+    else {
+      return false;
+    } 
+  }
+  
+  public Card getNext() {
+    //returns card
+    
+    if (hasNext() == true) {
+      nextCardIndex +=1;
+      return cards.get(nextCardIndex-1);
+    }
+    
+    else{
+      return null;
+    }
+  }
   
   public Deck(String filename) {
-    cards = new ArrayList<Card>(81);
     
     try {
       String line;
@@ -42,4 +84,6 @@ public Deck(String filename) {
       throw new RuntimeException("Error while reading file: " + e.toString());
     }
   }
+  
+  
 }
diff --git a/src/DeckTest.class b/src/DeckTest.class
new file mode 100644
index 0000000..e5498fc
Binary files /dev/null and b/src/DeckTest.class differ
diff --git a/src/DeckTest.java b/src/DeckTest.java
new file mode 100644
index 0000000..5c12011
--- /dev/null
+++ b/src/DeckTest.java
@@ -0,0 +1,42 @@
+import junit.framework.TestCase;
+
+/**
+ * A JUnit test case class.
+ * Every method starting with the word "test" will be called when running
+ * the test with JUnit.
+ */
+public class DeckTest extends TestCase {
+  
+  /**
+   * A test method.
+   * (Replace "X" with a name describing the test.  You may write as
+   * many "testSomething" methods in this class as you wish, and each
+   * one will be called when running JUnit over this class.)
+   */
+  public void testEmptyDeck() {
+    Deck d = new Deck("EmptyDeck.txt");
+    assertEquals(d.hasNext(), false);
+  }
+  
+  public void testAllCards() {
+    Deck d = new Deck("81cards.txt");
+    for (int i=0; i<81; i++) {     
+      assertEquals(d.hasNext(), true);
+      d.getNext();
+    }
+    d.getNext();
+    assertEquals(d.hasNext(), false);
+  }
+  
+  public void test3Cards() {
+    Deck d = new Deck("3cards.txt");
+    for (int i=0; i<3; i++) {
+      assertEquals(d.hasNext(), true);
+      d.getNext();
+    }
+    d.getNext();
+    assertEquals(d.hasNext(), false);
+  }
+  
+  
+}
diff --git a/src/EmptyDeck.text b/src/EmptyDeck.text
new file mode 100644
index 0000000..e69de29
diff --git a/src/Game.class b/src/Game.class
new file mode 100644
index 0000000..4068448
Binary files /dev/null and b/src/Game.class differ
diff --git a/src/Game.java b/src/Game.java
new file mode 100644
index 0000000..591d2fa
--- /dev/null
+++ b/src/Game.java
@@ -0,0 +1,181 @@
+public class Game{
+  private Deck d;
+  private Table t;
+  
+  public Game(){
+    //begins with randomly generated deck of 12 cards
+    
+    d = new Deck();
+    t = new Table();
+    
+    for (int i = 0; i<12; i++){
+      t.add(d.getNext());
+    }
+  }
+  
+  public Game(String filename){
+    //loads specific deck
+    
+    d = new Deck(filename);
+    t = new Table();
+    
+    while (d.hasNext()){
+      t.add(d.getNext());
+      
+      if (t.numCards() == 12){
+        return;
+      }
+    }
+  }
+  
+  public int numSets(){
+    //returns number of sets on the table
+    return t.numSets();
+  }
+  
+  public int numCards(){
+    
+    //returns number of cards on table which is 12 
+    //or less if deck has lest than 12 cards
+    return t.numCards();
+  }
+  
+  public void playRound(){
+    //used to advance game from one round to the next
+    //
+    //a round deals with removing one set 
+    //and adding additional cards
+    //
+    //1.)when no sets on table but still cards in deck:
+    //   this means just add 3 cards
+    //2.)most of the time:
+    //   cards in deck and 12 on table containing 1+ sets
+    //     in this situation we move from one round
+    //     to the next by removing one set and adding 3 cards
+    //     to the table from the deck
+    //3.)if a round starts with 12+ cards on table:
+    //   (due to no sets)
+    //   and theres is at least one set,
+    //   then after removing a set we do not add cards
+    //4.)if there is at least one set but no cards left:
+    //   we move to next round by just removing set
+    //5.)if no cards in deck or sets on table:
+    //   game over
+    //
+    //6.)sometimes when you use custom decks:
+    //   there may be only 1-2 cards remaining
+    //   when you have to add cards to table
+    //      in this case cards are added like normal
+    //      and the table remains short a few cards
+
+    int sets = t.numSets();
+
+    //1.)
+    if (sets == 0 && d.hasNext() == true){
+      for (int i = 0; i < 3; i++){
+        if (d.hasNext() == false){
+         return;
+        }
+        t.add(d.getNext());
+      }
+      return;
+    }
+    
+    
+    //2.)
+    if (sets > 0 && d.hasNext() == true){ 
+      //call the number of cards in the begining to make it quicker
+      int numCards = t.numCards();
+      //go through the table looking for the set
+      for (int i=0; i<numCards-2; i++) {
+        for (int j=i+1; j<numCards-1; j++){
+          for (int k=j+1; k<numCards; k++){
+                  
+            Card card1 = t.getCard(i);
+            Card card2 = t.getCard(j);
+            Card card3 = t.getCard(k);
+                  
+            if (card1.isSet(card2,card3)) {
+              t.removeSet(card1, card2, card3);
+              
+              for (int p = 0; t.numCards() < 12; p++){
+                if (d.hasNext() == false){
+                  return;
+                }
+                t.add(d.getNext());
+              }
+              return;
+            }
+          }
+        }
+       }
+      return;
+    }
+    
+    
+    //3.)
+    if (t.numCards() > 12 && sets > 0){
+      //call the number of cards in the begining to make it quicker
+      int numCards = t.numCards();
+      //go through the table looking for the set
+      for (int i=0; i<numCards-2; i++) {
+        for (int j=i+1; j<numCards-1; j++){
+          for (int k=j+1; k<numCards; k++){
+                  
+            Card card1 = t.getCard(i);
+            Card card2 = t.getCard(j);
+            Card card3 = t.getCard(k);
+                  
+            if (card1.isSet(card2,card3)) {
+              t.removeSet(card1, card2, card3);
+              return;
+            }
+          }
+        }
+      }
+      return;
+    }
+    
+    //4.)
+    if (sets > 0 && d.hasNext() == false){
+      //call the number of cards in the begining to make it quicker
+      int numCards = t.numCards();
+      //go through the table looking for the set
+      for (int i=0; i<numCards-2; i++) {
+        for (int j=i+1; j<numCards-1; j++){
+          for (int k=j+1; k<numCards; k++){
+                  
+            Card card1 = t.getCard(i);
+            Card card2 = t.getCard(j);
+            Card card3 = t.getCard(k);
+                  
+            if (card1.isSet(card2,card3)) {
+              t.removeSet(card1, card2, card3);
+              return;
+            }
+          }
+        }
+      }
+      return;
+    }
+    
+    //5.)
+    if (d.hasNext() == false && sets == 0){
+      return;
+    }
+
+  }
+  
+  public boolean isGameOver(){
+    //returns true only if there are no sets on table
+    // and no cards in deck
+    
+    if (d.hasNext() == false && t.numSets() == 0){
+      return true;
+    }
+    else {
+      return false;
+    }
+  }
+  
+}
\ No newline at end of file
diff --git a/src/GameTest.class b/src/GameTest.class
new file mode 100644
index 0000000..2c975f3
Binary files /dev/null and b/src/GameTest.class differ
diff --git a/src/GameTest.java b/src/GameTest.java
new file mode 100644
index 0000000..02f1b47
--- /dev/null
+++ b/src/GameTest.java
@@ -0,0 +1,108 @@
+import junit.framework.TestCase;
+
+/**
+ * A JUnit test case class.
+ * Every method starting with the word "test" will be called when running
+ * the test with JUnit.
+ */
+public class GameTest extends TestCase {
+  
+  /**
+   * A test method.
+   * (Replace "X" with a name describing the test.  You may write as
+   * many "testSomething" methods in this class as you wish, and each
+   * one will be called when running JUnit over this class.)
+   */
+  public void test1RoundGame() {
+    Game g = new Game();
+    
+    assertEquals(g.numCards(), 12);
+    g.playRound();
+    assertEquals(g.numCards(), 12);
+  }
+  
+  public void testWith81CardsDeck(){
+    Game g = new Game("81cards.txt");
+    
+    assertEquals(g.numCards(), 12);
+    assertEquals(g.numSets(), 13);
+    g.playRound();
+    assertEquals(g.numCards(), 12);
+    assertEquals(g.isGameOver(), false);
+  }
+  
+  public void test3cards1set(){
+    Game g = new Game("3cards.txt");
+    
+    assertEquals(g.numCards(), 3);
+    g.playRound();
+    assertEquals(g.numCards(), 0);
+  }
+  
+  public void testSommerDecks(){
+    Game g = new Game("3cards0setsMilestone.dat");
+    
+    assertEquals(g.numCards(), 3);
+    assertEquals(g.numSets(), 0);
+    g.playRound();
+    assertEquals(g.numCards(), 3);
+    assertEquals(g.isGameOver(), true);
+    
+    Game g1 = new Game("3cards1setMilestone.dat");
+    
+    assertEquals(g1.numCards(), 3);
+    assertEquals(g1.numSets(), 1);
+    g1.playRound();
+    assertEquals(g1.numCards(), 0);
+    assertEquals(g1.isGameOver(), true);
+    
+    Game g2 = new Game("12cards0setsMilestone.dat");
+    
+    assertEquals(g2.numCards(), 12);
+    assertEquals(g2.numSets(), 0);
+    g2.playRound();
+    assertEquals(g2.numCards(), 12);
+    assertEquals(g2.isGameOver(), true);
+    
+    Game g3 = new Game("12cards14setsMilestone.dat");
+    
+    assertEquals(g3.numCards(), 12);
+    assertEquals(g3.numSets(), 14);
+    g3.playRound();
+    assertEquals(g3.numCards(), 9);
+    assertEquals(g3.isGameOver(), false);
+    assertEquals(g3.numCards(), 9);
+    assertEquals(g3.numSets(), 8);
+    g3.playRound();
+    assertEquals(g3.numCards(), 6);
+    assertEquals(g3.isGameOver(), false);
+    assertEquals(g3.numSets(), 1);
+    assertEquals(g3.isGameOver(), false);
+    g3.playRound();
+    assertEquals(g3.numCards(), 3);
+    assertEquals(g3.numSets(), 0);
+    assertEquals(g3.isGameOver(), true);
+    assertEquals(g3.numCards(), 3);
+
+    Game g4 = new Game("emptyDeckMilestone.dat");
+    
+    assertEquals(g4.numCards(), 0);
+    assertEquals(g4.numSets(), 0);
+    g4.playRound();
+    assertEquals(g4.numCards(), 0);
+    assertEquals(g4.isGameOver(), true);
+    
+    Game g5 = new Game("deckMilestone.dat");
+    
+    assertEquals(g5.numCards(), 3);
+    assertEquals(g5.numSets(), 1);
+    g5.playRound();
+    assertEquals(g5.numCards(), 0);
+    assertEquals(g5.isGameOver(), true);
+    
+  }
+  
+  
+
+  
+}
diff --git a/src/MonteCarlo.class b/src/MonteCarlo.class
new file mode 100644
index 0000000..69a433c
Binary files /dev/null and b/src/MonteCarlo.class differ
diff --git a/src/MonteCarlo.java b/src/MonteCarlo.java
new file mode 100644
index 0000000..4dfe154
--- /dev/null
+++ b/src/MonteCarlo.java
@@ -0,0 +1,43 @@
+public class MonteCarlo{
+  public static void main(String[] args){
+    
+    // used to answer our two questions
+    
+    //will run a large number of independent experiments
+    //then take average of experiments
+    //this number is an estimate of the quantity measured
+    //the more experiements run the better the estimate
+    
+    //first question:
+    //What is the average number of sets in a random collection of 12 cards from the deck?
+    //count how many sets in a group of 12 random cards from a deck
+    //each experiment should use a different deck
+    //to keep experiment independent
+    
+    //second question:
+    //What is the average number of cards left at the end of the game?
+    //one experiment is one game played with a random deck
+    //when gameover you count the number of cards on table
+    
+    //use a main class
+    
+    
+    //1st Question && 2nd Question:
+    double avgNumberOfSets = 0;
+    double avgNumberOfCards = 0;
+    int i = 0;
+    while(i<=10000000){
+      Game g = new Game();
+      avgNumberOfSets += g.numSets();
+      while(g.isGameOver() == false) {
+        g.playRound();   
+      }
+      avgNumberOfCards += g.numCards();
+      i++;   
+    }
+    System.out.println("The average Number of Sets in " + (i-1) + " sets of random cards is " + avgNumberOfSets/(i-1));
+    System.out.println("The average Number of Cards left on the table at the end of a game after " + (i-1) + " games is " + avgNumberOfCards/(i-1));
+  
+  
+  }
+}
\ No newline at end of file
diff --git a/src/Table.class b/src/Table.class
new file mode 100644
index 0000000..c024498
Binary files /dev/null and b/src/Table.class differ
diff --git a/src/Table.java b/src/Table.java
new file mode 100644
index 0000000..2110c6d
--- /dev/null
+++ b/src/Table.java
@@ -0,0 +1,201 @@
+public class Table{
+    private TableNode head;
+    
+    public Table(){
+        head = null;
+    }
+    
+    public void add(Card newCard){
+        //new cards should be added to the front of the list
+        
+        TableNode newTableNode = new TableNode(newCard);
+        
+        // for an empty table
+        if (head == null) {
+            head = newTableNode;
+        }
+        
+        else {
+            newTableNode.setNext(head);
+            head = newTableNode;
+        }  
+    }
+    
+    
+    public void removeSet(Card card1, Card card2, Card card3){
+      //removes set from table
+      
+      //makes sure they're a set
+      if (card1.isSet(card2,card3) != true) {
+        return;
+      }
+      
+      //make sure the table isn't empty
+      if (head == null) {
+        return;
+      }
+      
+      //check if they're on the table and if they are assign them to variables
+      Card firstCard = null; 
+      Card secondCard = null;
+      Card thirdCard = null;
+      
+      //temp traverses through the list
+      TableNode temp = head;
+      TableNode prev = head;
+
+      //goes through list
+      while (temp != null) {
+        //check for first card 
+        
+        //make instance of card class
+        
+        //This if statement is where the infinite loop occurs
+        if (card1.equals(temp.getCard())) {
+          firstCard = card1;
+          temp = temp.getNext();
+        }
+        else if (card2.equals(temp.getCard())) {
+          secondCard = card2;
+          temp = temp.getNext();
+        }
+        else if (card3.equals(temp.getCard())) {
+          thirdCard = card3;
+          temp = temp.getNext();
+        }
+        else{
+          temp = temp.getNext();
+        }
+      }
+      
+      if (firstCard == null || secondCard == null || thirdCard == null) {
+        return;
+      }
+      
+      //if all cards are on table variables will equal cards given in parameter
+      if (card1.equals(firstCard) && card2.equals(secondCard) && card3.equals(thirdCard)) {
+        int i = 0;
+        while(i < 3) {
+
+          //sets the temp back to the head
+          temp = head;
+          prev = head;
+          
+          //loop until end to remove cards
+          while (temp.getNext() != null && i < 3) {
+            //for removing card at head or in middle
+            if (card1.equals(temp.getCard()) || card2.equals(temp.getCard()) || card3.equals(temp.getCard())){
+              if (temp == head){
+                head = temp.getNext();
+                prev = head;
+                temp = head;
+                i+=1;
+              }
+              else {
+                temp = temp.getNext();
+                prev.setNext(temp);
+                i+=1;
+              }
+            }
+            else {
+              if (temp == head){
+                temp = temp.getNext();
+              }
+              else{
+                temp = temp.getNext();
+                prev = prev.getNext();
+              }
+            }
+          }
+          
+          //for last card
+          if (temp.getNext()==null) {
+            if (card1.equals(temp.getCard()) || card2.equals(temp.getCard()) || card3.equals(temp.getCard())){
+              if (head.getNext()==null){
+                head=null;
+                i+=1;
+              }
+              else{
+              prev.setNext(null);
+              i+=1;
+              }
+            }
+            //might not need to be here
+            else {
+              return;
+            }
+          }
+        }
+      }
+      //if cards are not on table the method ends
+      else {
+        return;
+      }
+    }
+    
+    
+    
+    public int numCards(){
+        //returns number of cards on table
+        TableNode temp = head;
+        int i = 0;
+        if (head == null) {
+            return 0;
+        }
+        else{
+            while (temp != null) {
+                i += 1;
+                temp = temp.getNext();
+            }
+            return i;
+        }
+    }
+    
+    public Card getCard(int index){
+      // parameter is the index although it will remove the (n-1)th card on the table
+        //returns card at given int
+ 
+        TableNode temp = head;
+        if (temp == null) {
+            return null;
+        }
+        if (index == 0) {
+            return temp.getCard();
+        }
+        else {  // this may cause errors maybe change to j < index
+          for (int j = 0; j<index; j++){
+            temp = temp.getNext();
+            }
+          if (temp == null) {
+            return null;
+          }
+          else {
+            return temp.getCard();
+          }
+        }
+    }
+    
+    public int numSets(){
+        //returns the number of Sets on the table
+      int sets = 0;
+      int numCards = numCards();
+
+        for (int i=0; i<numCards-2; i++) {
+            for (int j=i+1; j<numCards-1; j++){
+                for (int k=j+1; k<numCards; k++){
+                  
+                        Card card1 = getCard(i);
+                        Card card2 = getCard(j);
+                        Card card3 = getCard(k);
+                  
+                  if (card1.isSet(card2,card3)) {
+                    sets += 1;
+                  }
+                }
+            }
+        }
+        return sets;
+    }
+    
+    //end
+}
\ No newline at end of file
diff --git a/src/TableNode.class b/src/TableNode.class
new file mode 100644
index 0000000..d0929be
Binary files /dev/null and b/src/TableNode.class differ
diff --git a/src/TableNode.java b/src/TableNode.java
new file mode 100644
index 0000000..6acf3df
--- /dev/null
+++ b/src/TableNode.java
@@ -0,0 +1,23 @@
+public class TableNode{
+    private Card card;
+    private TableNode next;
+    
+    public TableNode(Card newCard){
+        //should set card to given parameter and next field to null
+      card = newCard;
+      next = null;
+    }
+    
+    public void setNext(TableNode newNext){
+        next = newNext;
+    }
+    
+    public TableNode getNext(){
+        return next;
+    }
+    
+    public Card getCard(){
+        return card;
+    }
+    
+}
diff --git a/src/TableNodeTest.class b/src/TableNodeTest.class
new file mode 100644
index 0000000..cd94021
Binary files /dev/null and b/src/TableNodeTest.class differ
diff --git a/src/TableNodeTest.java b/src/TableNodeTest.java
new file mode 100644
index 0000000..72047c6
--- /dev/null
+++ b/src/TableNodeTest.java
@@ -0,0 +1,30 @@
+import junit.framework.TestCase;
+
+/**
+ * A JUnit test case class.
+ * Every method starting with the word "test" will be called when running
+ * the test with JUnit.
+ */
+public class TableNodeTest extends TestCase {
+  
+  /**
+   * A test method.
+   * (Replace "X" with a name describing the test.  You may write as
+   * many "testSomething" methods in this class as you wish, and each
+   * one will be called when running JUnit over this class.)
+   */
+  public void testTableNode() {
+    Card c = new Card(1,1,1,1);
+    Card c2 = new Card(2,2,2,2);
+    TableNode t = new TableNode(c);
+    TableNode t2 = new TableNode(c2);
+    Table table = new Table();
+    
+    
+    assertEquals(t.getNext(), null);
+    t.setNext(t2);
+    assertEquals(t.getNext(), t2);
+    assertEquals(t.getCard(), c);
+  }
+  
+}
diff --git a/src/TableTest.class b/src/TableTest.class
new file mode 100644
index 0000000..2a9df9d
Binary files /dev/null and b/src/TableTest.class differ
diff --git a/src/TableTest.java b/src/TableTest.java
new file mode 100644
index 0000000..7c6ba14
--- /dev/null
+++ b/src/TableTest.java
@@ -0,0 +1,93 @@
+import junit.framework.TestCase;
+
+/**
+ * A JUnit test case class.
+ * Every method starting with the word "test" will be called when running
+ * the test with JUnit.
+ */
+public class TableTest extends TestCase {
+  
+  /**
+   * A test method.
+   * (Replace "X" with a name describing the test.  You may write as
+   * many "testSomething" methods in this class as you wish, and each
+   * one will be called when running JUnit over this class.)
+   */
+  public void testTable() {
+    Table t = new Table();
+    Card c1 = new Card(1,1,1,1);
+    Card c2 = new Card(2,2,2,2);
+    Card c3 = new Card(3,3,3,3);
+    assertEquals(t.numCards(), 0);
+    t.add(c1);
+    assertEquals(t.numCards(), 1);
+    t.add(c2);
+    assertEquals(t.numCards(), 2);
+    t.add(c3);
+    assertEquals(t.numCards(), 3);
+   
+    assertEquals(t.getCard(0), c3);
+    assertEquals(t.getCard(1), c2);
+    assertEquals(t.getCard(2), c1);
+    assertEquals(t.numSets(), 1);
+    
+    Card c4 = new Card(4,4,4,4);
+    Card c5 = new Card(5,5,5,5);
+    Card c6 = new Card(6,6,6,6);
+    t.add(c4);
+    t.add(c5);
+    t.add(c6);
+    
+    assertEquals(c4.isSet(c5,c6), true);
+    assertEquals(t.numCards(), 6);
+    assertEquals(t.numSets(), 8);
+    
+    assertEquals(t.getCard(0), c1);
+    
+    
+    t.removeSet(c1,c2,c3);
+    
+    assertEquals(t.numCards(), 3);
+    
+  }
+  
+  public void fullTable() {
+    Table t = new Table();
+    Card c1 = new Card(2,1,1,1);
+    Card c2 = new Card(2,2,1,2);
+    Card c3 = new Card(3,1,3,3);
+    Card c11 = new Card(1,1,1,1);
+    Card c22 = new Card(2,3,3,1);
+    Card c33 = new Card(3,3,3,3);
+    Card c111 = new Card(2,1,2,1);
+    Card c222 = new Card(2,2,2,2);
+    Card c333 = new Card(3,3,2,1);
+    Card c1111 = new Card(1,3,1,2);
+    Card c2222 = new Card(3,3,2,2);
+    Card c3333 = new Card(3,3,3,3);
+    Card c4 = new Card(1,1,1,1);
+    Card c5 = new Card(2,2,2,2);
+    Card c6 = new Card(3,3,3,3);
+    
+    t.add(c1);
+    t.add(c2);
+    t.add(c3);
+    t.add(c11);
+    t.add(c22);
+    t.add(c33);
+    t.add(c111);
+    t.add(c222);
+    t.add(c333);
+    t.add(c1111);
+    t.add(c2222);
+    t.add(c3333);
+    t.add(c4);
+    t.add(c5);
+    t.add(c6);
+    
+    t.removeSet(c1,c2,c3);
+    
+    assertEquals(t.numCards(), 9);
+  }
+
+}
diff --git a/src/TableTestMilestone.class b/src/TableTestMilestone.class
new file mode 100644
index 0000000..7d1df88
--- /dev/null
+++ b/src/TableTestMilestone.class
@@ -0,0 +1 @@
+# emptydeckk
\ No newline at end of file
diff --git a/src/deckMilestone.dat b/src/deckMilestone.dat
new file mode 100755
index 0000000..a7f4bbf
--- /dev/null
+++ b/src/deckMilestone.dat
@@ -0,0 +1,12 @@
+# Lines starting with a # character are comments, and ignored
+# Blank lines are also ignored, even if they contain whitespace
+   
+# All other lines are expected to have 4 integers, separated by spaces
+1 1 1 1
+1 1 1 2
+1 1 1 3
+
+# A file does not need to contain all 81 cards
+
+  
+  
diff --git a/src/emptyDeckMilestone.dat b/src/emptyDeckMilestone.dat
new file mode 100755
index 0000000..fa71407
--- /dev/null
+++ b/src/emptyDeckMilestone.dat
@@ -0,0 +1 @@
+# Nothing here!
\ No newline at end of file