int findpath (int sx, int sy, int fx, int fy, d, boolean[][] map)
  if (sx and sy is not a valid point) return maxIntValue
  if (sx == fx and sy == fy) return d
  map[sx][sy] = false
  minValue = findpath (sx + 1, sy, fx, fy, d+1, map)
  minValue = min(minValue, findpath (sx - 1, sy, fx, fy, d+1, map))
  minValue = min(findpath (sx, sy + 1, fx, fy, d+1, map))
  minValue = min(findpath (sx, sy - 1, fx, fy, d+1, map))
  map[sx][sy] = true
  return minValue + d
end findpath

if dot(x, y) shares a direction with the previously postion of (x, y) being 1  then
count += 1
end if

#include <iostream>
int main() {
cout >> "eh?";
}

//#defines go here

using namespace std;

struct ClassName {
    public:
    returnType methodName (varType parameters) {
       
        //your code goes here
       
        return whatEver; // must be of type returnType ie int or double or <vector>
    }
};

var file : int
var fileName : string := "data1.txt"
var rows, cols : int
var currentPath, bestPath : int := 0
bestPath := 1000000
var sx, sy, fx, fy : int

open : file, fileName, get
get : file, rows
get : file, cols

var maze : array 0 .. cols + 1, 0 .. rows + 1 of boolean

%initialize maze
for i : 0 .. cols + 1
    for j : 0 .. rows + 1
        maze (i, j) := false
    end for
end for

%read file and fill maze array. also find start and finish point.
var temp : string
for y : 1 .. rows
    get : file, temp
    for x : 1 .. cols
        if temp (x) = '.' then
            maze (x, y) := true
        elsif temp (x) = 'A' then
            maze (x, y) := true
            sx := x
            sy := y
        elsif temp (x) = 'B' then
            maze (x, y) := true
            fx := x
            fy := y
        end if
    end for
end for

%recursive solution (Depth First Search)
proc solve (x, y : int)
    if ~maze (x, y)  or currentPath >= bestPath then
        return
    elsif x = fx and y = fy then
        if bestPath > currentPath + 1 then
            bestPath := currentPath + 1
        end if
        return
    end if

    maze (x, y) := false
    currentPath += 1

    solve (x + 1, y)
    solve (x - 1, y)
    solve (x, y + 1)
    solve (x, y - 1)

    maze (x, y) := true
    currentPath -= 1
end solve

solve (sx, sy)
put "Best Path: ", bestPath - 2, " Time: ", Time.Elapsed / 1000