'''simple docstring'''




import math
import sys

class   _lowercase:



   """simple docstring"""





   def __init__(							self:    Any	):
    __UpperCAmelCase         =					0
    __UpperCAmelCase         =					[]
    __UpperCAmelCase         =					{}  # To store the pos of node in array





   def 			snake_case	(							self:    str	):
    return self.cur_size == 0





   def 			snake_case	(							self:    Optional[int]			,a:    Dict	):
    __UpperCAmelCase         =					self.left(a	)
    __UpperCAmelCase         =					self.right(a	)
    if lc < self.cur_size and self.array(a	)[0] < self.array(a	)[0]:
     __UpperCAmelCase         =					lc
    else:
     __UpperCAmelCase         =					idx
    if rc < self.cur_size and self.array(a	)[0] < self.array(a	)[0]:
     __UpperCAmelCase         =					rc
    if smallest != idx:
     self.swap(a			,a	)
     self.min_heapify(a	)





   def 			snake_case	(							self:    List[str]			,a:    str	):
    # Inserts a node into the Priority Queue
    __UpperCAmelCase         =					self.cur_size
    self.cur_size += 1
    self.array.append((sys.maxsize, tup[1])	)
    self.decrease_key((sys.maxsize, tup[1])			,tup[0]	)





   def 			snake_case	(							self:    str	):
    # Removes and returns the min element at top of priority queue
    __UpperCAmelCase         =					self.array[0][1]
    __UpperCAmelCase         =					self.array[self.cur_size - 1]
    self.cur_size -= 1
    self.min_heapify(1	)
    del self.pos[min_node]
    return min_node





   def 			snake_case	(							self:    str			,a:    str	):
    # returns the index of left child
    return 2 * i + 1





   def 			snake_case	(							self:    Tuple			,a:    Dict	):
    # returns the index of right child
    return 2 * i + 2





   def 			snake_case	(							self:    Optional[int]			,a:    Any	):
    # returns the index of parent
    return math.floor(i / 2	)





   def 			snake_case	(							self:    List[Any]			,a:    Dict			,a:    Any	):
    # swaps array elements at indices i and j
    # update the pos{}
    __UpperCAmelCase         =					j
    __UpperCAmelCase         =					i
    __UpperCAmelCase         =					self.array[i]
    __UpperCAmelCase         =					self.array[j]
    __UpperCAmelCase         =					temp





   def 			snake_case	(							self:    Optional[Any]			,a:    Any			,a:    Union[str, Any]	):
    __UpperCAmelCase         =					self.pos[tup[1]]
    # assuming the new_d is atmost old_d
    __UpperCAmelCase         =					(new_d, tup[1])
    while idx > 0 and self.array[self.par(a	)][0] > self.array[idx][0]:
     self.swap(a			,self.par(a	)	)
     __UpperCAmelCase         =					self.par(a	)




class   _lowercase:



   """simple docstring"""





   def __init__(							self:    Optional[int]			,a:    Optional[Any]	):
    __UpperCAmelCase         =					{}  # To store graph: u -> (v,w)
    __UpperCAmelCase         =					num  # Number of nodes in graph
    # To store the distance from source vertex
    __UpperCAmelCase         =					[0] * self.num_nodes
    __UpperCAmelCase         =					[-1] * self.num_nodes  # To store the path





   def 			snake_case	(							self:    List[str]			,a:    int			,a:    Optional[Any]			,a:    List[Any]	):
    #  Edge going from node u to v and v to u with weight w
    # u (w)-> v, v (w) -> u
    # Check if u already in graph
    if u in self.adjList:
     self.adjList[u].append((v, w)	)
    else:
     __UpperCAmelCase         =					[(v, w)]

    # Assuming undirected graph
    if v in self.adjList:
     self.adjList[v].append((u, w)	)
    else:
     __UpperCAmelCase         =					[(u, w)]





   def 			snake_case	(							self:    Tuple	):
    # u -> v(w)
    for u in self.adjList:
     print(a			,'->'			,' -> '.join(str(f"""{v}({w})"""	) for v, w in self.adjList[u]	)	)





   def 			snake_case	(							self:    Optional[Any]			,a:    int	):
    # Flush old junk values in par[]
    __UpperCAmelCase         =					[-1] * self.num_nodes
    # src is the source node
    __UpperCAmelCase         =					0
    __UpperCAmelCase         =					PriorityQueue()
    q.insert((0, src)	)  # (dist from src, node)
    for u in self.adjList:
     if u != src:
      __UpperCAmelCase         =					sys.maxsize  # Infinity
      __UpperCAmelCase         =					-1

    while not q.is_empty():
     __UpperCAmelCase         =					q.extract_min()  # Returns node with the min dist from source
     # Update the distance of all the neighbours of u and
     # if their prev dist was INFINITY then push them in Q
     for v, w in self.adjList[u]:
      __UpperCAmelCase         =					self.dist[u] + w
      if self.dist[v] > new_dist:
       if self.dist[v] == sys.maxsize:
        q.insert((new_dist, v)	)
       else:
        q.decrease_key((self.dist[v], v)			,a	)
       __UpperCAmelCase         =					new_dist
       __UpperCAmelCase         =					u

        # Show the shortest distances from src
    self.show_distances(a	)





   def 			snake_case	(							self:    str			,a:    int	):
    print(f"""Distance from node: {src}"""	)
    for u in range(self.num_nodes	):
     print(f"""Node {u} has distance: {self.dist[u]}"""	)





   def 			snake_case	(							self:    Dict			,a:    Any			,a:    List[str]	):
    # To show the shortest path from src to dest
    # WARNING: Use it *after* calling dijkstra
    __UpperCAmelCase         =					[]
    __UpperCAmelCase         =					0
    __UpperCAmelCase         =					dest
    # Backtracking from dest to src
    while self.par[temp] != -1:
     path.append(a	)
     if temp != src:
      for v, w in self.adjList[temp]:
       if v == self.par[temp]:
        cost += w
        break
     __UpperCAmelCase         =					self.par[temp]
    path.append(a	)
    path.reverse()

    print(f"""----Path to reach {dest} from {src}----"""	)
    for u in path:
     print(f"""{u}"""			,end=' '	)
     if u != dest:
      print('-> '			,end=''	)

    print('\nTotal cost of path: '			,a	)


if __name__ == "__main__":
     _UpperCamelCase				:		List[Any]       			=		Graph(9)
     graph.add_edge(0, 1, 4)
     graph.add_edge(0, 7, 8)
     graph.add_edge(1, 2, 8)
     graph.add_edge(1, 7, 11)
     graph.add_edge(2, 3, 7)
     graph.add_edge(2, 8, 2)
     graph.add_edge(2, 5, 4)
     graph.add_edge(3, 4, 9)
     graph.add_edge(3, 5, 14)
     graph.add_edge(4, 5, 10)
     graph.add_edge(5, 6, 2)
     graph.add_edge(6, 7, 1)
     graph.add_edge(6, 8, 6)
     graph.add_edge(7, 8, 7)
     graph.show_graph()
     graph.dijkstra(0)
     graph.show_path(0, 4)

# OUTPUT
# 0 -> 1(4) -> 7(8)
# 1 -> 0(4) -> 2(8) -> 7(11)
# 7 -> 0(8) -> 1(11) -> 6(1) -> 8(7)
# 2 -> 1(8) -> 3(7) -> 8(2) -> 5(4)
# 3 -> 2(7) -> 4(9) -> 5(14)
# 8 -> 2(2) -> 6(6) -> 7(7)
# 5 -> 2(4) -> 3(14) -> 4(10) -> 6(2)
# 4 -> 3(9) -> 5(10)
# 6 -> 5(2) -> 7(1) -> 8(6)
# Distance from node: 0
# Node 0 has distance: 0
# Node 1 has distance: 4
# Node 2 has distance: 12
# Node 3 has distance: 19
# Node 4 has distance: 21
# Node 5 has distance: 11
# Node 6 has distance: 9
# Node 7 has distance: 8
# Node 8 has distance: 14
# ----Path to reach 4 from 0----
# 0 -> 7 -> 6 -> 5 -> 4
# Total cost of path:  21




'''simple docstring'''




def 						__snake_case (       lowerCAmelCase       :     list			):

 for insert_index, insert_value in enumerate(collection[1:]			):
  __UpperCAmelCase         =					insert_index
  while insert_index >= 0 and insert_value < collection[insert_index]:
   __UpperCAmelCase         =					collection[insert_index]
   insert_index -= 1
  if insert_index != temp_index:
   __UpperCAmelCase         =					insert_value
 return collection


if __name__ == "__main__":
     from doctest import testmod

     testmod()

     _UpperCamelCase				:		List[Any]       			=		input('Enter numbers separated by a comma:\n').strip()
     _UpperCamelCase				:		List[Any]       			=		[int(item) for item in user_input.split(',')]
     print(f"{insertion_sort(unsorted) = }")



