import math
def 					_snake_case	(  __snake_case						):

					if 1 < number < 4:
										# 2 and 3 are primes
										return True
					elif number < 2 or number % 2 == 0 or number % 3 == 0:
										# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
										return False

					# All primes number are in format of 6k +/- 1
					for i in range(5  ,     int(math.sqrt(__snake_case						) + 1						)  ,     6						):
										if number % i == 0 or number % (i + 2) == 0:
															return False
					return True
def 					_snake_case	(  __snake_case = 10001						):

					try:
										_UpperCamelCase			     =     int(__snake_case						)
					except (TypeError, ValueError):
										raise TypeError('''Parameter nth must be int or castable to int.'''						) from None
					if nth <= 0:
										raise ValueError('''Parameter nth must be greater than or equal to one.'''						)
					_UpperCamelCase			     =     []
					_UpperCamelCase			     =     2
					while len(__snake_case						) < nth:
										if is_prime(__snake_case						):
															primes.append(__snake_case						)
															num += 1
										else:
															num += 1
					return primes[len(__snake_case						) - 1]


if __name__ == "__main__":
					print(f'{solution() = }')

import math
class     lowerCAmelCase_     :







							def __init__(   self      :     Tuple ,			_A      :     int=0		):  # a graph with Node 0,1,...,N-1
												_UpperCamelCase			     =     n
												_UpperCamelCase			     =     [
												    [math.inf for j in range(0 ,			_A		)] for i in range(0 ,			_A		)
												]  # adjacency matrix for weight
												_UpperCamelCase			     =     [
												    [math.inf for j in range(0 ,			_A		)] for i in range(0 ,			_A		)
												]  # dp[i][j] stores minimum distance from i to j







							def  UpperCamelCase_						(   self      :     Dict ,			_A      :     str ,			_A      :     List[str] ,			_A      :     Optional[Any]		):
												_UpperCamelCase			     =     w







							def  UpperCamelCase_						(   self      :     Optional[int]		):
												for k in range(0 ,			self.n		):
																	for i in range(0 ,			self.n		):
																						for j in range(0 ,			self.n		):
																											_UpperCamelCase			     =     min(self.dp[i][j] ,			self.dp[i][k] + self.dp[k][j]		)







							def  UpperCamelCase_						(   self      :     List[str] ,			_A      :     Optional[int] ,			_A      :     Optional[int]		):
												return self.dp[u][v]


if __name__ == "__main__":
					_lowerCAmelCase       =		Graph(5)
					graph.add_edge(0, 2, 9)
					graph.add_edge(0, 4, 10)
					graph.add_edge(1, 3, 5)
					graph.add_edge(2, 3, 7)
					graph.add_edge(3, 0, 10)
					graph.add_edge(3, 1, 2)
					graph.add_edge(3, 2, 1)
					graph.add_edge(3, 4, 6)
					graph.add_edge(4, 1, 3)
					graph.add_edge(4, 2, 4)
					graph.add_edge(4, 3, 9)
					graph.floyd_warshall()
					graph.show_min(1, 4)
					graph.show_min(0, 3)
