def depth$\_$first$\_$search$($initial$\_$state, goal$\_$states, grid$\_$size, initial$\_$walls$)$:

# Initialize a stack with the initial state and an empty path

stack $=[($Node$($grid$\_$size, initial$\_$state, goal$\_$states$),[])]$

# Initialize an empty set to keep track of visited states

visited $=$ set$()$

# Initialize a counter for the number of nodes explored

nodes$\_$explored $=0$

# Initialize a dictionary to keep track of the number of visits to each goal state

goal$\_$visits $=\{$goal$\_$state: $0$ for goal$\_$state in goal$\_$states$\}$

# Continue searching until the stack is empty

while stack:

# Pop the top node from the stack along with its current path

current$\_$node, path $=$ stack.pop$()$

# Increment the node exploration counter

nodes$\_$explored $+=1$

# Check if the current node is one of the goal states

if current$\_$node.state in goal$\_$states:

# If so$,$ update the visit count for the current goal state and return the path along with the number of nodes explored

goal$\_$visits$[$current$\_$node.state$]+=1$

return path, nodes$\_$explored

# If the current node has not been visited yet

if current$\_$node.state not in visited:

# Add the current node's state to the visited set

visited.add$($current$\_$node.state$)$

# Create a copy of the initial walls configuration

current$\_$walls $=$ initial$\_$walls.copy$()$

# Get neighbors of the current node considering jump actions with max$\_$jump$=4$

neighbors $=$ current$\_$node.get$\_$neighbors$($current$\_$walls, max$\_$jump$=4)$

# Iterate over the neighbors

for neighbor, cost in neighbors:

# Check if the neighbor has not been visited and is not a wall

if neighbor not in visited and neighbor not in current$\_$walls:

# Create a child node with the neighbor state, linking it to the current node

child$\_$node $=$ Node$($grid$\_$size, neighbor, goal$\_$states, parent$=$current$\_$node, cost$=$current$\_$node.cost $+$ cost$)$ # Include the cost

# Append the neighbor state to the current path to create a new path

new$\_$path $=$ path $+[$neighbor$]$

# Push the child node onto the stack along with the new path

stack.append$(($child$\_$node, new$\_$path$))$

# If no solution is found within the depth limit$,$ return None

return None, nodes$\_$explored

could anyone check my dfs code and where its going wrong?