



"""simple docstring"""






from __future__ import annotations

class 			__SCREAMING_SNAKE_CASE      :


					'''simple docstring'''





					def __init__(			self				:    List[str],    lowerCamelCase				:    int	)->   None:
								lowerCamelCase__						:						Any						      =vertices
								lowerCamelCase__						:						Optional[Any]						      =[[0] * vertices for _ in range(lowerCamelCase	)]



					def 						snake_case			(			self				:    Optional[int],    lowerCamelCase				:    list[int]	)->   None:
								print('''Vertex \t Distance from Source'''	)
								for vertex in range(self.vertices	):
											print(lowerCamelCase,    '''\t\t''',    distances_from_source[vertex]	)



					def 						snake_case			(			self				:    Optional[int],    lowerCamelCase				:    list[int],    lowerCamelCase				:    list[bool]	)->   int:
								lowerCamelCase__						:						Optional[int]						      =1E7
								lowerCamelCase__						:						int						      =0

								# Search not nearest vertex not in the shortest path tree
								for vertex in range(self.vertices	):
											if distances_from_source[vertex] < minimum and visited[vertex] is False:
														lowerCamelCase__						:						Tuple						      =distances_from_source[vertex]
														lowerCamelCase__						:						Any						      =vertex
								return min_index




					def 						snake_case			(			self				:    Any,    lowerCamelCase				:    int	)->   None:
								lowerCamelCase__						:						Union[str, Any]						      =[int(1E7	)] * self.vertices  # distances from the source
								lowerCamelCase__						:						int						      =0
								lowerCamelCase__						:						Optional[int]						      =[False] * self.vertices

								for _ in range(self.vertices	):
											lowerCamelCase__						:						int						      =self.minimum_distance(lowerCamelCase,    lowerCamelCase	)
											lowerCamelCase__						:						List[Any]						      =True

											# Update dist value of the adjacent vertices
											# of the picked vertex only if the current
											# distance is greater than new distance and
											# the vertex in not in the shortest path tree
											for v in range(self.vertices	):
														if (
														    self.graph[u][v] > 0
														    and visited[v] is False
														    and distances[v] > distances[u] + self.graph[u][v]
														):
																	lowerCamelCase__						:						Dict						      =distances[u] + self.graph[u][v]

								self.print_solution(lowerCamelCase	)


if __name__ == "__main__":
		_lowercase					:					List[str] 		=		Graph(9)
		_lowercase					:					Optional[int] 		=		[
		    [0, 4, 0, 0, 0, 0, 0, 8, 0],
		    [4, 0, 8, 0, 0, 0, 0, 1_1, 0],
		    [0, 8, 0, 7, 0, 4, 0, 0, 2],
		    [0, 0, 7, 0, 9, 1_4, 0, 0, 0],
		    [0, 0, 0, 9, 0, 1_0, 0, 0, 0],
		    [0, 0, 4, 1_4, 1_0, 0, 2, 0, 0],
		    [0, 0, 0, 0, 0, 2, 0, 1, 6],
		    [8, 1_1, 0, 0, 0, 0, 1, 0, 7],
		    [0, 0, 2, 0, 0, 0, 6, 7, 0],
		]
		graph.dijkstra(0)









"""simple docstring"""






def 	snake_case__  (						__lowerCamelCase							:       str				,						__lowerCamelCase							:       int = 13      ):
			"""simple docstring"""
			lowerCamelCase__						:						List[str]						      =''''''
			for c in s:
						if "A" <= c <= "Z":
									out += chr(ord('''A'''      ) + (ord(__lowerCamelCase      ) - ord('''A'''      ) + n) % 26      )
						elif "a" <= c <= "z":
									out += chr(ord('''a'''      ) + (ord(__lowerCamelCase      ) - ord('''a'''      ) + n) % 26      )
						else:
									out += c
			return out






def 	snake_case__  (						):
			"""simple docstring"""
			lowerCamelCase__						:						List[str]						      =input('''Enter message: '''      )

			lowerCamelCase__						:						str						      =dencrypt(__lowerCamelCase				,						13      )
			print('''Encryption:'''				,						__lowerCamelCase      )

			lowerCamelCase__						:						Any						      =dencrypt(__lowerCamelCase				,						13      )
			print('''Decryption: '''				,						__lowerCamelCase      )


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		main()




