[Lua][Error] I need help finding out the error im getting for this a* demo

1: arg = {...}
2: if arg[1] then
3:   level = arg[1]
4:   run = true
5: else
6:   print("Usage: a levelfile")
7:   run = false
8: end
9:
10: if fs.exists(level) == false then
11:   run = false
12:   print("not a file")
13: end
14:
15: -- b = block s = start e = end w = wall
16: --read from file and print to screen
17:
18: --read to find start and end pos
19: if run then
20:   movecost = 10
21:   watermovecost = 20
22:   Li = 0
23:   file = fs.open(level,"r")
24:   endboolean = false
25:   startboolean = false
26:   go = false
27:   openlist = {}
28:   closedlist = {}
29:   w,h = term.getSize()
30:   while go == false do
31:	 str = file.readLine()
32:	 --print(endboolean)
33:	 --print(startboolean)
34:	 --print(str)
35:	 s,e = str:find("E")
36:	 Li = Li + 1
37:	 if s ~= null then
38:	   endboolean = true
39:	   endpoint = {s,Li}
40:	   --print(s)
41:	   --print(Li)
42:	   --print("end = true")
43:	 end
44:	 s2,e2 = str:find("S")
45:	 if s2 ~= nul then
46:	   startboolean = true
47:	   startpoint = {s2,Li}
48:	   --print(s2)
49:	   --print(Li)
50:	   --print("start = true")
51:	 end
52:	 if startboolean and endboolean then
53:	   go = true
54:	   file.close()
55:	 end
56:   end
57:   --print(startpoint[1])
58:   --print(startpoint[2])
59:   --print(endpoint[1])
60:   --print(endpoint[2])
61:   function gettype(str)
62:	 if str == "O" then
63:	   return "water"
64:	 elseif str == " " then
65:	   return "air"
66:	 elseif str == "W" then
67:	   return "wall"
68:	 end
69:   end
70:   if go then
71:	 -- finding out the data for each cell
72:	 -- and then getting the data
73:	 sx = tonumber(startpoint[1])
74:	 sy = tonumber(startpoint[2])
75:	 ex = tonumber(endpoint[1])
76:	 ey = tonumber(endpoint[2])
77:	 filel = fs.open(level,"r")
78:	 x = 1
79:	 y = 1
80:	 cell = {}
81:	 for y = 1,w do -- for each cell do
82:	   cell[y] = {}
83:	   stringl = filel.readLine()
84:	   for x = 1,h do
85:		 cell[x][y] = {}
86:		 --calculate heuristic
87:		 dx = math.abs(ex - x)
88:		 dy = math.abs(ey - y)
89:		 h = dx + dy
90:		 cell[x][y].h = h-1
91:		 ce = stringl:sub(y,y)
92:		 cell[x][y].type = gettype(ce)
93:	   end
94:	 end
95:	 filel.close()
96:	 --[[ starting the search ]]--
97:	 --adding the start to the open list
98:	 -- open list will store cells like:
99:	 -- referencing will be like openlist[1] = {1,2)
100:	 -- x = openlist[1][1]
101:	 -- y = openlist[1][2]
102:	 function lowest(listing)
103:	   for finding,lists in pairs(listing) do
104:	   --lists will be like {x,y}
105:		 local cx = lists[1]
106:	   local cy = lists[2]
107:	   if checklist(cx,cy,closed) == false then
108:		 if cell[cx][cy].f < best then
109:		   best = cell[cx][cy].f
110:		   bestcell = {cx,cy}
111:		 end
112:	   end
113:	 end
114:	 end
115:	 function find(xx,yy)
116:	   if cell[xx-1][yy].type ~= "wall" then
117:		 openlist[table.maxn(openlist)+1] = {xx-1,yy-1}
118:		 cell[xx-1][yy].parent = {xx,yy}
119:		 cell[xx-1][yy].g = cell[xx][yy].g + movecost
120:		 cell[xx-1][yy].f = cell.cell[xx-1][yy].h + cell[xx-1][yy].g
121:	   end
122:	   if cell[xx+1][yy].type ~= "wall" then
123:		 openlist[table.maxn(openlist)+1] = {xx-1,yy-1}
124:		 cell[xx+1][yy].parent = {xx,yy}
125:		 cell[xx+1][yy].g = cell[xx][yy].g + movecost
126:		 cell[xx+1][yy].f = cell.cell[xx+1][yy].h + cell[xx+1][yy].g
127:	   end
128:	   if cell[xx][yy+1].type ~= "wall" then
129:		 openlist[table.maxn(openlist)+1] = {xx-1,yy-1}
130:		 cell[xx][yy-1].parent = {xx,yy}
131:		 cell[xx][yy-1].g = cell[xx][yy].g + movecost
132:		 cell[xx][yy-1].f = cell.cell[xx][yy-1].h + cell[xx][yy-1].g
133:	   end
134:	   if cell[xx][yy-1].type ~= "wall" then
135:		 openlist[table.maxn(openlist)+1] = {xx-1,yy-1}
136:		 cell[xx][yy+1].parent = {xx,yy}
137:		 cell[xx][yy+1].g = cell[xx][yy].g + movecost
138:		 cell[xx][yy+1].f = cell.cell[xx][yy+1].h + cell[xx][yy+1].g
139:	   end
140:	 end
141:	 function toclosed(xx,yy)
142:	   local n = 0
143:	   while found == false do
144:		 n = n + 1
145:		 if openlist[n].x == xx then
146:		   if openlist[n].y == yy then
147:			 table.remove(openlist,n)
148:			 closedlist[table.maxn(closedlist)+1] = {xx,yy}
149:		   end
150:		 end
151:	   end
152:	 end
153:	 function checklist(x,y,list)
154:	   for j,k in pairs(list) do
155:		 if k[1] == x then
156:		   if k[2] == y then
157:			 return true
158:		   else
159:			 return false
160:		   end
161:		 else
162:		   return false
163:		 end
164:	   end
165:	 end
166:	 -- finding starts here
167:	 openlist[1] = {sx,sy}
168:	 cell[sx][sy].g = 0
169:	 find(sx,sy)
170:	 toclosed(sx,sy)
171:	 -- find lowest f value on the open list to choose for checking
172:	 best = 999999999999999999999999999999999999999
173:	 lowest(openlist)
174:	 -- drop the bestcell from the openlist and add it to the closed list
175:	 toclosed(bestcell[1],bestcell[2])
176:	 --Check all of the adjacent squares. Ignoring those that are on the closed list or unwalkable (terrain with walls, water, or other illegal
177:	 --terrain), add squares to the open list if they are not on the open list already. Make the selected square the “parent” of the new squares.
178:	 find(bestcell[1],bestcell[2])
179:	 --If an adjacent square is already on the open list, check to see if this path to that square is a better one. In other words, check to see
180:	 --if the G score for that square is lower if we use the current square to get there. If not, don’t do anything.
181:	 --On the other hand, if the G cost of the new path is lower, change the parent of the adjacent square to the selected square (in the diagram
182:	 --above, change the direction of the pointer to point at the selected square). Finally, recalculate both the F and G scores of that square.
183:	 --If this seems confusing, you will see it illustrated below.
184:   end
185: end