



"""simple docstring"""







def      __UpperCAmelCase      (    __lowerCamelCase						,     __lowerCamelCase	)							->      List[Any]:
		print('''\nThe shortest path matrix using Floyd Warshall algorithm\n'''	)
		for i in range(__lowerCamelCase	):
				for j in range(__lowerCamelCase	):
						if dist[i][j] != float('''inf'''	):
								print(int(dist[i][j]	)						,     end='''\t'''	)
						else:
								print('''INF'''						,     end='''\t'''	)
				print()



def      __UpperCAmelCase      (    __lowerCamelCase						,     __lowerCamelCase	)							->      Optional[Any]:
		lowercase__   :    str				=			[[float('''inf'''	) for _ in range(__lowerCamelCase	)] for _ in range(__lowerCamelCase	)]

		for i in range(__lowerCamelCase	):
				for j in range(__lowerCamelCase	):
						lowercase__   :    List[str]				=			graph[i][j]

						# check vertex k against all other vertices (i, j)
		for k in range(__lowerCamelCase	):
				# looping through rows of graph array
				for i in range(__lowerCamelCase	):
						# looping through columns of graph array
						for j in range(__lowerCamelCase	):
								if (
								    dist[i][k] != float('''inf'''	)
								    and dist[k][j] != float('''inf'''	)
								    and dist[i][k] + dist[k][j] < dist[i][j]
								):
										lowercase__   :    str				=			dist[i][k] + dist[k][j]

		_print_dist(__lowerCamelCase						,     __lowerCamelCase	)
		return dist, v


if __name__ == "__main__":
							lowerCAmelCase_   						=   int(input('Enter number of vertices: '))
							lowerCAmelCase_   						=   int(input('Enter number of edges: '))

							lowerCAmelCase_   						=   [[float('inf') for i in range(v)] for j in range(v)]

							for i in range(v):
														lowerCAmelCase_   						=   0.0

														# src and dst are indices that must be within the array size graph[e][v]
														# failure to follow this will result in an error
							for i in range(e):
														print('\nEdge ', i + 1)
														lowerCAmelCase_   						=   int(input('Enter source:'))
														lowerCAmelCase_   						=   int(input('Enter destination:'))
														lowerCAmelCase_   						=   float(input('Enter weight:'))
														lowerCAmelCase_   						=   weight

							floyd_warshall(graph, v)

							# Example Input
							# Enter number of vertices: 3
							# Enter number of edges: 2

							# # generated graph from vertex and edge inputs
							# [[inf, inf, inf], [inf, inf, inf], [inf, inf, inf]]
							# [[0.0, inf, inf], [inf, 0.0, inf], [inf, inf, 0.0]]

							# specify source, destination and weight for edge #1
							# Edge  1
							# Enter source:1
							# Enter destination:2
							# Enter weight:2

							# specify source, destination and weight for edge #2
							# Edge  2
							# Enter source:2
							# Enter destination:1
							# Enter weight:1

							# # Expected Output from the vertice, edge and src, dst, weight inputs!!
							# 0		INF	INF
							# INF	0	2
							# INF	1	0




from __future__ import annotations

import bisect


def        _UpperCamelCase							(      lowercase__    ,       lowercase__    ,       lowercase__ = 0    ,       lowercase__ = -1      ):
						if hi < 0:
												__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		len(lowercase__      )

						while lo < hi:
												__SCREAMING_SNAKE_CASE						:     Any					=		lo + (hi - lo) // 2
												if sorted_collection[mid] < item:
																		__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		mid + 1
												else:
																		__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		mid

						return lo


def        _UpperCamelCase							(      lowercase__    ,       lowercase__    ,       lowercase__ = 0    ,       lowercase__ = -1      ):
						if hi < 0:
												__SCREAMING_SNAKE_CASE						:     List[Any]					=		len(lowercase__      )

						while lo < hi:
												__SCREAMING_SNAKE_CASE						:     Optional[int]					=		lo + (hi - lo) // 2
												if sorted_collection[mid] <= item:
																		__SCREAMING_SNAKE_CASE						:     Any					=		mid + 1
												else:
																		__SCREAMING_SNAKE_CASE						:     Optional[int]					=		mid

						return lo


def        _UpperCamelCase							(      lowercase__    ,       lowercase__    ,       lowercase__ = 0    ,       lowercase__ = -1      ):
						sorted_collection.insert(bisect_left(lowercase__    ,       lowercase__    ,       lowercase__    ,       lowercase__      )    ,       lowercase__      )


def        _UpperCamelCase							(      lowercase__    ,       lowercase__    ,       lowercase__ = 0    ,       lowercase__ = -1      ):
						sorted_collection.insert(bisect_right(lowercase__    ,       lowercase__    ,       lowercase__    ,       lowercase__      )    ,       lowercase__      )


def        _UpperCamelCase							(      lowercase__    ,       lowercase__      ):
						__SCREAMING_SNAKE_CASE						:     Any					=		0
						__SCREAMING_SNAKE_CASE						:     List[Any]					=		len(lowercase__      ) - 1

						while left <= right:
												__SCREAMING_SNAKE_CASE						:     str					=		left + (right - left) // 2
												__SCREAMING_SNAKE_CASE						:     List[str]					=		sorted_collection[midpoint]
												if current_item == item:
																		return midpoint
												elif item < current_item:
																		__SCREAMING_SNAKE_CASE						:     int					=		midpoint - 1
												else:
																		__SCREAMING_SNAKE_CASE						:     Dict					=		midpoint + 1
						return None


def        _UpperCamelCase							(      lowercase__    ,       lowercase__      ):
						__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		bisect.bisect_left(lowercase__    ,       lowercase__      )
						if index != len(lowercase__      ) and sorted_collection[index] == item:
												return index
						return None


def        _UpperCamelCase							(      lowercase__    ,       lowercase__    ,       lowercase__    ,       lowercase__      ):
						if right < left:
												return None

						__SCREAMING_SNAKE_CASE						:     int					=		left + (right - left) // 2

						if sorted_collection[midpoint] == item:
												return midpoint
						elif sorted_collection[midpoint] > item:
												return binary_search_by_recursion(lowercase__    ,       lowercase__    ,       lowercase__    ,       midpoint - 1      )
						else:
												return binary_search_by_recursion(lowercase__    ,       lowercase__    ,       midpoint + 1    ,       lowercase__      )


if __name__ == "__main__":
						__lowerCAmelCase	: Dict  				=input('Enter numbers separated by comma:\n').strip()
						__lowerCAmelCase	: str  				=sorted(int(item) for item in user_input.split(','))
						__lowerCAmelCase	: Tuple  				=int(input('Enter a single number to be found in the list:\n'))
						__lowerCAmelCase	: Tuple  				=binary_search(collection, target)
						if result is None:
												print(f"""{target} was not found in {collection}.""")
						else:
												print(f"""{target} was found at position {result} in {collection}.""")
