"""simple docstring"""





# Author: OMKAR PATHAK, Nwachukwu Chidiebere

# Use a Python dictionary to construct the graph.
from __future__ import annotations

from pprint import pformat
from typing import Generic, TypeVar

__A  =				TypeVar('''T''')
class  _snake_case     (					Generic[T]		):






						def __init__(       self      :			List[str]							,					UpperCAmelCase      :			bool = True    ):
													__lowerCamelCase					:		dict[T, list[T]]		   =     {}  # dictionary of lists
													__lowerCamelCase					:		int		   =     directed






						def       lowerCamelCase__     (       self      :			Dict							,					UpperCAmelCase      :			T							,					UpperCAmelCase      :			T    ):

													if not self.directed:  # For undirected graphs
																				# if both source vertex and destination vertex are both present in the
																				# adjacency list, add destination vertex to source vertex list of adjacent
																				# vertices and add source vertex to destination vertex list of adjacent
																				# vertices.
																				if source_vertex in self.adj_list and destination_vertex in self.adj_list:
																											self.adj_list[source_vertex].append(UpperCAmelCase    )
																											self.adj_list[destination_vertex].append(UpperCAmelCase    )
																				# if only source vertex is present in adjacency list, add destination vertex
																				# to source vertex list of adjacent vertices, then create a new vertex with
																				# destination vertex as key and assign a list containing the source vertex
																				# as it's first adjacent vertex.
																				elif source_vertex in self.adj_list:
																											self.adj_list[source_vertex].append(UpperCAmelCase    )
																											__lowerCamelCase					:		List[Any]		   =     [source_vertex]
																				# if only destination vertex is present in adjacency list, add source vertex
																				# to destination vertex list of adjacent vertices, then create a new vertex
																				# with source vertex as key and assign a list containing the source vertex
																				# as it's first adjacent vertex.
																				elif destination_vertex in self.adj_list:
																											self.adj_list[destination_vertex].append(UpperCAmelCase    )
																											__lowerCamelCase					:		Optional[Any]		   =     [destination_vertex]
																				# if both source vertex and destination vertex are not present in adjacency
																				# list, create a new vertex with source vertex as key and assign a list
																				# containing the destination vertex as it's first adjacent vertex also
																				# create a new vertex with destination vertex as key and assign a list
																				# containing the source vertex as it's first adjacent vertex.
																				else:
																											__lowerCamelCase					:		Optional[int]		   =     [destination_vertex]
																											__lowerCamelCase					:		str		   =     [source_vertex]
													else:  # For directed graphs
																				# if both source vertex and destination vertex are present in adjacency
																				# list, add destination vertex to source vertex list of adjacent vertices.
																				if source_vertex in self.adj_list and destination_vertex in self.adj_list:
																											self.adj_list[source_vertex].append(UpperCAmelCase    )
																				# if only source vertex is present in adjacency list, add destination
																				# vertex to source vertex list of adjacent vertices and create a new vertex
																				# with destination vertex as key, which has no adjacent vertex
																				elif source_vertex in self.adj_list:
																											self.adj_list[source_vertex].append(UpperCAmelCase    )
																											__lowerCamelCase					:		Union[str, Any]		   =     []
																				# if only destination vertex is present in adjacency list, create a new
																				# vertex with source vertex as key and assign a list containing destination
																				# vertex as first adjacent vertex
																				elif destination_vertex in self.adj_list:
																											__lowerCamelCase					:		List[str]		   =     [destination_vertex]
																				# if both source vertex and destination vertex are not present in adjacency
																				# list, create a new vertex with source vertex as key and a list containing
																				# destination vertex as it's first adjacent vertex. Then create a new vertex
																				# with destination vertex as key, which has no adjacent vertex
																				else:
																											__lowerCamelCase					:		Optional[int]		   =     [destination_vertex]
																											__lowerCamelCase					:		List[str]		   =     []

													return self







						def __repr__(       self      :			List[str]    ):
													return pformat(self.adj_list    )
"""simple docstring"""





from __future__ import annotations


def    lowercase_   (   _lowerCamelCase:	list[list[int]]      ) ->      bool:



							'''simple docstring'''

							__lowerCamelCase					:		str		   =     len(_lowerCamelCase      )
							# We need to create solution object to save path.
							__lowerCamelCase					:		List[Any]		   =     [[0 for _ in range(_lowerCamelCase      )] for _ in range(_lowerCamelCase      )]
							__lowerCamelCase					:		Dict		   =     run_maze(_lowerCamelCase						,   0						,   0						,   _lowerCamelCase      )
							if solved:
														print("\n".join(str(_lowerCamelCase      ) for row in solutions      )      )
							else:
														print("No solution exists!"      )
							return solved


def    lowercase_   (   _lowerCamelCase:	list[list[int]]						,   _lowerCamelCase:	int						,   _lowerCamelCase:	int						,   _lowerCamelCase:	list[list[int]]      ) ->      bool:



							'''simple docstring'''

							__lowerCamelCase					:		Dict		   =     len(_lowerCamelCase      )
							# Final check point.
							if i == j == (size - 1):
														__lowerCamelCase					:		Optional[Any]		   =     1
														return True

							__lowerCamelCase					:		int		   =     (not i < 0) and (not j < 0)  # Check lower bounds
							__lowerCamelCase					:		Union[str, Any]		   =     (i < size) and (j < size)  # Check upper bounds

							if lower_flag and upper_flag:
														# check for already visited and block points.
														__lowerCamelCase					:		List[Any]		   =     (not solutions[i][j]) and (not maze[i][j])
														if block_flag:
																					# check visited
																					__lowerCamelCase					:		Dict		   =     1

																					# check for directions
																					if (
																					    run_maze(_lowerCamelCase						,   i + 1						,   _lowerCamelCase						,   _lowerCamelCase      )
																					    or run_maze(_lowerCamelCase						,   _lowerCamelCase						,   j + 1						,   _lowerCamelCase      )
																					    or run_maze(_lowerCamelCase						,   i - 1						,   _lowerCamelCase						,   _lowerCamelCase      )
																					    or run_maze(_lowerCamelCase						,   _lowerCamelCase						,   j - 1						,   _lowerCamelCase      )
																					):
																												return True

																					__lowerCamelCase					:		List[str]		   =     0
																					return False
							return False


if __name__ == "__main__":
				import doctest

				doctest.testmod()