diff --git a/src/SalamanderSearch.java b/src/SalamanderSearch.java
index 688cda7..af88bce 100644
--- a/src/SalamanderSearch.java
+++ b/src/SalamanderSearch.java
@@ -1,6 +1,4 @@
-import java.util.ArrayList;
-import java.util.List;
-
+import java.util.*;
 public class SalamanderSearch {
     public static void main(String[] args) {
         char[][] enclosure1 = {
@@ -18,6 +16,15 @@ public static void main(String[] args) {
             {'f','W','.','.','W','.'},
             {'W','.','W','.','.','.'},
         };
+        Set<int[]> coordinateSet = new HashSet<>();
+        int[] coord1 = new int[] {1,5};
+        int[] coord2 = new int[] {3,7};
+        int[] coord3 = new int[] {1,5};
+        coordinateSet.add(coord1);
+        coordinateSet.add(coord2);
+        coordinateSet.add(coord3);
+
+        System.out.println(coordinateSet.size());
     }
 
     /**
@@ -42,7 +49,92 @@ public static void main(String[] args) {
      * @param enclosure
      * @return whether the salamander can reach the food
      */
-    public static boolean canReach(char[][] enclosure) {
+
+    public static int[] salamanderLocation (char [][] enclosure) {
+        for(int r = 0; r < enclosure.length;  r++ ){
+            for (int c = 0; c < enclosure[0].length; c++){
+                if(enclosure[r][c] == 's'){
+                    return new int[]{r,c};
+                }
+            }
+        }
+        throw new IllegalArgumentException("No salamander present");
+    }
+
+    public static List<int[]> possibleMoves(char[][] enclosure, int[] current){
+        int curR = current[0];
+        int curC = current[1];
+
+        List<int[]> moves = new ArrayList<>();  
+
+        int[][] directions = new int[][]{
+            {-1,0},
+            {1,0},
+            {0,-1},
+            {0,1}
+        };
+
+        for (int[] direction : directions){
+            int newR = curR + direction[0];
+            int newC = curC + direction[1];
+
+            if(newR >= 0 && newR < enclosure.length &&
+               newC >=0 && newC < enclosure[0].length &&
+               enclosure[newR][newC] != 'W'){
+                moves.add(new int[]{newR, newC});
+               } 
+        }
+        
+        /*//up
+        int newR = (curR -1);
+        int newC = (curC);
+        if( newR >= 0 && enclosure[newR][newC] != 'W'){
+            moves.add(new int[]{newR, newC});
+        }
+        //down
+        newR = (curR + 1);
+        newC = (curC);
+        if ( newR < enclosure.length && enclosure[newR][newC] != 'W'){
+            moves.add(new int[]{newR, newC});
+        };
+
+        newR = (curR);
+        newC = (curC - 1);
+        if(newC >= 0 && enclosure[newR][newC] != 'W'){
+            moves.add(new int[]{newR, newC});
+        }
+
+        newR = (curR);
+        newC = (curC + 1);
+        if(newC < enclosure[0].length && enclosure[newR][newC] != 'W'){
+            moves.add(new int[]{newR, newC});
+        }
+        */
+//
+        return moves;
+
+
+    }
+
+    public static boolean canReach (char[][] enclosure){
+        int[] start = salamanderLocation(enclosure);
+        boolean[][] visited = new boolean[enclosure.length][enclosure[0].length];
+        return canReach (enclosure, start, visited);
+    }
+
+    public static boolean canReach(char[][] enclosure, int[] current, boolean[][] visited){
+        int curR = current[0];
+        int curC = current[1];
+
+        if(visited[curR][curC]) return false;
+        if(enclosure[curR][curC] == 'f') return true;
+
+        visited[curR][curC] = true; 
+
+        List<int[]> moves = possibleMoves(enclosure, current);
+        for(int[] move : moves){
+            if(canReach(enclosure, move, visited)) return true;
+        }
         return false;
     }
 }
diff --git a/src/SalamanderSearchTest.java b/src/SalamanderSearchTest.java
index ddad9de..ed10d3c 100644
--- a/src/SalamanderSearchTest.java
+++ b/src/SalamanderSearchTest.java
@@ -34,203 +34,203 @@ public void canReach_NoPath() {
         assertFalse(actual);
     }
 
-    // @Test
-    // public void testSalamanderLocation_centerOfGrid() {
-    //     char[][] enclosure = {
-    //         {'.', '.', '.'},
-    //         {'.', 's', '.'},
-    //         {'.', '.', '.'}
-    //     };
-    //     int[] expected = {1, 1};
-    //     assertArrayEquals(expected, SalamanderSearch.salamanderLocation(enclosure));
-    // }
-
-    // @Test
-    // public void testSalamanderLocation_topLeftCorner() {
-    //     char[][] enclosure = {
-    //         {'s', '.', '.'},
-    //         {'.', '.', '.'},
-    //         {'.', '.', '.'}
-    //     };
-    //     int[] expected = {0, 0};
-    //     assertArrayEquals(expected, SalamanderSearch.salamanderLocation(enclosure));
-    // }
-
-    // @Test
-    // public void testSalamanderLocation_notFound_throwsException() {
-    //     char[][] enclosure = {
-    //         {'.', '.', '.'},
-    //         {'.', '.', '.'},
-    //         {'.', '.', '.'}
-    //     };
-    //     Exception exception = assertThrows(IllegalArgumentException.class, () -> {
-    //         SalamanderSearch.salamanderLocation(enclosure);
-    //     });
-    //     assertEquals("No salamander present", exception.getMessage());
-    // }
-
-
-    // @Test
-    // public void testSalamanderLocation_at_1_2() {
-    //     char[][] enclosure = {
-    //         {'.', '.', '.'},
-    //         {'.', '.', 's'},
-    //         {'.', '.', '.'}
-    //     };
-    //     int[] expected = {1, 2};
-    //     assertArrayEquals(expected, SalamanderSearch.salamanderLocation(enclosure));
-    // }
-
-    // @Test
-    // public void testPossibleMoves_allDirectionsOpen() {
-    //     char[][] enclosure = {
-    //         {'.', '.', '.'},
-    //         {'.', 's', '.'},
-    //         {'.', '.', '.'}
-    //     };
-    //     int[] location = {1, 1};
-    //     List<int[]> moves = SalamanderSearch.possibleMoves(enclosure, location);
-    //     Set<String> moveSet = toSet(moves);
-
-    //     assertEquals(4, moves.size());
-    //     assertTrue(moveSet.contains("0,1")); // up
-    //     assertTrue(moveSet.contains("2,1")); // down
-    //     assertTrue(moveSet.contains("1,0")); // left
-    //     assertTrue(moveSet.contains("1,2")); // right
-    // }
-
-    // @Test
-    // public void testPossibleMoves_allDirectionsBlockedByWalls() {
-    //     char[][] enclosure = {
-    //         {'W', 'W', 'W'},
-    //         {'W', 's', 'W'},
-    //         {'W', 'W', 'W'}
-    //     };
-    //     int[] location = {1, 1};
-    //     List<int[]> moves = SalamanderSearch.possibleMoves(enclosure, location);
-    //     assertTrue(moves.isEmpty());
-    // }
-
-    // @Test
-    // public void testPossibleMoves_partialEdge() {
-    //     char[][] enclosure = {
-    //         {'s', '.', '.'}
-    //     };
-    //     int[] location = {0, 0};
-    //     List<int[]> moves = SalamanderSearch.possibleMoves(enclosure, location);
-    //     Set<String> moveSet = toSet(moves);
-
-    //     assertEquals(1, moves.size());
-    //     assertTrue(moveSet.contains("0,1")); // only right
-    // }
-
-    // @Test
-    // public void testPossibleMoves_oneOpen_twoWalls_oneEdge() {
-    //     // Salamander at (1, 1)
-    //     // Up is W, down is wall, left is edge (0), right is open
-    //     char[][] enclosure = {
-    //         {'W', 'W', 'W'},
-    //         {'.', 's', '.'},
-    //         {'W', 'W', 'W'}
-    //     };
-    //     int[] location = {1, 1};
-    //     List<int[]> moves = SalamanderSearch.possibleMoves(enclosure, location);
-    //     Set<String> moveSet = toSet(moves);
-
-    //     assertEquals(2, moves.size());
-    //     assertTrue(moveSet.contains("1,2"));
-    //     assertTrue(moveSet.contains("1,0"));
-    // }
-
-    // @Test
-    // public void testPossibleMoves_blockedAboveByWall() {
-    //     char[][] enclosure = {
-    //         {'.', 'W', '.'},
-    //         {'.', 's', '.'},
-    //         {'.', '.', '.'}
-    //     };
-    //     int[] location = {1, 1};
-    //     List<int[]> moves = SalamanderSearch.possibleMoves(enclosure, location);
-    //     Set<String> moveSet = toSet(moves);
-
-    //     assertFalse(moveSet.contains("0,1")); // up blocked
-    //     assertTrue(moveSet.contains("2,1"));  // down open
-    //     assertTrue(moveSet.contains("1,0"));  // left open
-    //     assertTrue(moveSet.contains("1,2"));  // right open
-    // }
-
-    // @Test
-    // public void testPossibleMoves_blockedBelowByWall() {
-    //     char[][] enclosure = {
-    //         {'.', '.', '.'},
-    //         {'.', 's', '.'},
-    //         {'.', 'W', '.'}
-    //     };
-    //     int[] location = {1, 1};
-    //     Set<String> moveSet = toSet(SalamanderSearch.possibleMoves(enclosure, location));
-
-    //     assertTrue(moveSet.contains("0,1"));  // up open
-    //     assertFalse(moveSet.contains("2,1")); // down blocked
-    //     assertTrue(moveSet.contains("1,0"));  // left open
-    //     assertTrue(moveSet.contains("1,2"));  // right open
-    // }
-
-    // @Test
-    // public void testPossibleMoves_blockedLeftByWall() {
-    //     char[][] enclosure = {
-    //         {'.', '.', '.'},
-    //         {'W', 's', '.'},
-    //         {'.', '.', '.'}
-    //     };
-    //     int[] location = {1, 1};
-    //     Set<String> moveSet = toSet(SalamanderSearch.possibleMoves(enclosure, location));
-
-    //     assertTrue(moveSet.contains("0,1"));  // up open
-    //     assertTrue(moveSet.contains("2,1"));  // down open
-    //     assertFalse(moveSet.contains("1,0")); // left blocked
-    //     assertTrue(moveSet.contains("1,2"));  // right open
-    // }
-
-    // @Test
-    // public void testPossibleMoves_blockedRightByWall() {
-    //     char[][] enclosure = {
-    //         {'.', '.', '.'},
-    //         {'.', 's', 'W'},
-    //         {'.', '.', '.'}
-    //     };
-    //     int[] location = {1, 1};
-    //     Set<String> moveSet = toSet(SalamanderSearch.possibleMoves(enclosure, location));
-
-    //     assertTrue(moveSet.contains("0,1"));  // up open
-    //     assertTrue(moveSet.contains("2,1"));  // down open
-    //     assertTrue(moveSet.contains("1,0"));  // left open
-    //     assertFalse(moveSet.contains("1,2")); // right blocked
-    // }
-
-    // @Test
-    // public void testPossibleMoves_topLeftCornerWithOneOpen() {
-    //     char[][] enclosure = {
-    //         {'s', 'W'},
-    //         {'W', '.'}
-    //     };
-    //     int[] location = {0, 0};
-    //     List<int[]> moves = SalamanderSearch.possibleMoves(enclosure, location);
-
-    //     assertTrue(moves.isEmpty()); // surrounded by walls/edges
-    // }
-
-    // @Test
-    // public void testPossibleMoves_rightEdgeWithOpenLeft() {
-    //     char[][] enclosure = {
-    //         {'.', '.', 's'}
-    //     };
-    //     int[] location = {0, 2};
-    //     List<int[]> moves = SalamanderSearch.possibleMoves(enclosure, location);
-    //     Set<String> moveSet = toSet(moves);
-
-    //     assertEquals(1, moves.size());
-    //     assertTrue(moveSet.contains("0,1"));
-    // }
+     @Test
+     public void testSalamanderLocation_centerOfGrid() {
+         char[][] enclosure = {
+             {'.', '.', '.'},
+             {'.', 's', '.'},
+             {'.', '.', '.'}
+         };
+         int[] expected = {1, 1};
+         assertArrayEquals(expected, SalamanderSearch.salamanderLocation(enclosure));
+     }
+
+     @Test
+     public void testSalamanderLocation_topLeftCorner() {
+         char[][] enclosure = {
+             {'s', '.', '.'},
+             {'.', '.', '.'},
+             {'.', '.', '.'}
+         };
+         int[] expected = {0, 0};
+         assertArrayEquals(expected, SalamanderSearch.salamanderLocation(enclosure));
+     }
+
+     @Test
+     public void testSalamanderLocation_notFound_throwsException() {
+         char[][] enclosure = {
+             {'.', '.', '.'},
+             {'.', '.', '.'},
+             {'.', '.', '.'}
+         };
+         Exception exception = assertThrows(IllegalArgumentException.class, () -> {
+             SalamanderSearch.salamanderLocation(enclosure);
+         });
+         assertEquals("No salamander present", exception.getMessage());
+     }
+
+
+     @Test
+     public void testSalamanderLocation_at_1_2() {
+        char[][] enclosure = {
+             {'.', '.', '.'},
+             {'.', '.', 's'},
+             {'.', '.', '.'}
+         };
+         int[] expected = {1, 2};
+         assertArrayEquals(expected, SalamanderSearch.salamanderLocation(enclosure));
+     }
+
+     @Test
+     public void testPossibleMoves_allDirectionsOpen() {
+         char[][] enclosure = {
+             {'.', '.', '.'},
+             {'.', 's', '.'},
+             {'.', '.', '.'}
+         };
+         int[] location = {1, 1};
+         List<int[]> moves = SalamanderSearch.possibleMoves(enclosure, location);
+         Set<String> moveSet = toSet(moves);
+
+         assertEquals(4, moves.size());
+         assertTrue(moveSet.contains("0,1"));  //up
+         assertTrue(moveSet.contains("2,1"));  //down
+         assertTrue(moveSet.contains("1,0"));  //left
+         assertTrue(moveSet.contains("1,2"));  //right
+     }
+
+     @Test
+     public void testPossibleMoves_allDirectionsBlockedByWalls() {
+         char[][] enclosure = {
+             {'W', 'W', 'W'},
+             {'W', 's', 'W'},
+             {'W', 'W', 'W'}
+         };
+         int[] location = {1, 1};
+         List<int[]> moves = SalamanderSearch.possibleMoves(enclosure, location);
+         assertTrue(moves.isEmpty());
+     }
+
+     @Test
+     public void testPossibleMoves_partialEdge() {
+         char[][] enclosure = {
+             {'s', '.', '.'}
+         };
+         int[] location = {0, 0};
+         List<int[]> moves = SalamanderSearch.possibleMoves(enclosure, location);
+         Set<String> moveSet = toSet(moves);
+
+         assertEquals(1, moves.size());
+         assertTrue(moveSet.contains("0,1"));  //only right
+     }
+
+     @Test
+     public void testPossibleMoves_oneOpen_twoWalls_oneEdge() {
+          //Salamander at (1, 1);
+          //Up is W, down is wall, left is edge (0), //right is open
+         char[][] enclosure = {
+             {'W', 'W', 'W'},
+             {'.', 's', '.'},
+             {'W', 'W', 'W'}
+         };
+         int[] location = {1, 1};
+         List<int[]> moves = SalamanderSearch.possibleMoves(enclosure, location);
+         Set<String> moveSet = toSet(moves);
+
+         assertEquals(2, moves.size());
+         assertTrue(moveSet.contains("1,2"));
+         assertTrue(moveSet.contains("1,0"));
+     }
+
+     @Test
+     public void testPossibleMoves_blockedAboveByWall() {
+         char[][] enclosure = {
+             {'.', 'W', '.'},
+             {'.', 's', '.'},
+             {'.', '.', '.'}
+         };
+         int[] location = {1, 1};
+         List<int[]> moves = SalamanderSearch.possibleMoves(enclosure, location);
+         Set<String> moveSet = toSet(moves);
+
+         assertFalse(moveSet.contains("0,1"));  //up blocked
+         assertTrue(moveSet.contains("2,1"));   //down open
+         assertTrue(moveSet.contains("1,0"));   //left open
+         assertTrue(moveSet.contains("1,2"));   //right open
+     }
+
+     @Test
+     public void testPossibleMoves_blockedBelowByWall() {
+         char[][] enclosure = {
+             {'.', '.', '.'},
+             {'.', 's', '.'},
+             {'.', 'W', '.'}
+         };
+         int[] location = {1, 1};
+         Set<String> moveSet = toSet(SalamanderSearch.possibleMoves(enclosure, location));
+
+         assertTrue(moveSet.contains("0,1"));   //up open
+         assertFalse(moveSet.contains("2,1"));  //down blocked
+         assertTrue(moveSet.contains("1,0"));   //left open
+         assertTrue(moveSet.contains("1,2"));   //right open
+     }
+
+     @Test
+     public void testPossibleMoves_blockedLeftByWall() {
+         char[][] enclosure = {
+             {'.', '.', '.'},
+             {'W', 's', '.'},
+             {'.', '.', '.'}
+         };
+         int[] location = {1, 1};
+         Set<String> moveSet = toSet(SalamanderSearch.possibleMoves(enclosure, location));
+
+         assertTrue(moveSet.contains("0,1"));   //up open
+         assertTrue(moveSet.contains("2,1"));   //down open
+         assertFalse(moveSet.contains("1,0"));  //left blocked
+         assertTrue(moveSet.contains("1,2"));   //right open
+     }
+
+     @Test
+     public void testPossibleMoves_blockedRightByWall() {
+         char[][] enclosure = {
+             {'.', '.', '.'},
+             {'.', 's', 'W'},
+             {'.', '.', '.'}
+         };
+         int[] location = {1, 1};
+         Set<String> moveSet = toSet(SalamanderSearch.possibleMoves(enclosure, location));
+
+         assertTrue(moveSet.contains("0,1"));   //up open
+         assertTrue(moveSet.contains("2,1"));   //down open
+         assertTrue(moveSet.contains("1,0"));   //left open
+         assertFalse(moveSet.contains("1,2"));  //right blocked
+     }
+
+     @Test
+     public void testPossibleMoves_topLeftCornerWithOneOpen() {
+         char[][] enclosure = {
+             {'s', 'W'},
+             {'W', '.'}
+         };
+         int[] location = {0, 0};
+         List<int[]> moves = SalamanderSearch.possibleMoves(enclosure, location);
+
+         assertTrue(moves.isEmpty());  //surrounded by walls/edges
+     }
+
+     @Test
+     public void testPossibleMoves_rightEdgeWithOpenLeft() {
+         char[][] enclosure = {
+             {'.', '.', 's'}
+         };
+         int[] location = {0, 2};
+         List<int[]> moves = SalamanderSearch.possibleMoves(enclosure, location);
+         Set<String> moveSet = toSet(moves);
+
+         assertEquals(1, moves.size());
+         assertTrue(moveSet.contains("0,1"));
+     }
 
 
     private Set<String> toSet(List<int[]> list) {