



"""simple docstring"""






class  __SCREAMING_SNAKE_CASE			:


					'''simple docstring'''





					def __init__( self							:						Any,						lowerCamelCase							:						int  )->      List[str]:
								lowerCamelCase__	:	Any				=n
								lowerCamelCase__	:	Tuple				=[None] * self.n
								lowerCamelCase__	:	Tuple				=0  # index of the first element
								lowerCamelCase__	:	Union[str, Any]				=0
								lowerCamelCase__	:	Union[str, Any]				=0



					def __len__( self							:						Optional[Any]  )->      int:
								return self.size



					def 	snake_case ( self							:						str  )->      bool:
								return self.size == 0



					def 	snake_case ( self							:						str  )->      str:
								return False if self.is_empty() else self.array[self.front]



					def 	snake_case ( self							:						List[str],						lowerCamelCase							:						Optional[Any]  )->      Optional[Any]:
								if self.size >= self.n:
											raise Exception('''QUEUE IS FULL'''  )

								lowerCamelCase__	:	Any				=data
								lowerCamelCase__	:	int				=(self.rear + 1) % self.n
								self.size += 1
								return self




					def 	snake_case ( self							:						List[Any]  )->      Dict:
								if self.size == 0:
											raise Exception('''UNDERFLOW'''  )

								lowerCamelCase__	:	Dict				=self.array[self.front]
								lowerCamelCase__	:	Optional[int]				=None
								lowerCamelCase__	:	List[str]				=(self.front + 1) % self.n
								self.size -= 1
								return temp









"""simple docstring"""






def   snake_case__     (	__lowerCamelCase       :					list[list[int]]							,	__lowerCamelCase       :					int							,	__lowerCamelCase       :					int							,	__lowerCamelCase       :					list[int]			):
			"""simple docstring"""

			# 1. Validate that path exists between current and next vertices
			if graph[path[curr_ind - 1]][next_ver] == 0:
						return False

			# 2. Validate that next vertex is not already in path
			return not any(vertex == next_ver for vertex in path			)






def   snake_case__     (	__lowerCamelCase       :					list[list[int]]							,	__lowerCamelCase       :					list[int]							,	__lowerCamelCase       :					int			):
			"""simple docstring"""

			# Base Case
			if curr_ind == len(__lowerCamelCase			):
						# return whether path exists between current and starting vertices
						return graph[path[curr_ind - 1]][path[0]] == 1

			# Recursive Step
			for next_ver in range(0							,	len(__lowerCamelCase			)			):
						if valid_connection(__lowerCamelCase							,	__lowerCamelCase							,	__lowerCamelCase							,	__lowerCamelCase			):
									# Insert current vertex  into path as next transition
									lowerCamelCase__	:	Tuple				=next_ver
									# Validate created path
									if util_hamilton_cycle(__lowerCamelCase							,	__lowerCamelCase							,	curr_ind + 1			):
												return True
									# Backtrack
									lowerCamelCase__	:	int				=-1
			return False






def   snake_case__     (	__lowerCamelCase       :					list[list[int]]							,	__lowerCamelCase       :					int = 0			):
			"""simple docstring"""
			lowerCamelCase__	:	Tuple				=[-1] * (len(__lowerCamelCase			) + 1)
			# initialize start and end of path with starting index
			lowerCamelCase__	:	Union[str, Any]				=start_index
			# evaluate and if we find answer return path either return empty array
			return path if util_hamilton_cycle(__lowerCamelCase							,	__lowerCamelCase							,	1			) else []




