






class 	_UpperCAmelCase  :




      """simple docstring"""



      def __init__(   self		):



          '''simple docstring'''
          lowerCAmelCase__   :List[Any]      							=				{}
      def 			snake_case_      (   self		):



          '''simple docstring'''
          print(self.vertex		)
          for i in self.vertex:
              print(_lowerCAmelCase    ,	" -> "    ,	" -> ".join([str(_lowerCAmelCase		) for j in self.vertex[i]]		)		)
      def 			snake_case_      (   self    ,	_lowerCAmelCase    ,	_lowerCAmelCase		):



          '''simple docstring'''
          # check if vertex is already present,
          if from_vertex in self.vertex:
              self.vertex[from_vertex].append(_lowerCAmelCase		)
          else:
              # else make a new vertex
              lowerCAmelCase__   :str      							=				[to_vertex]
      def 			snake_case_      (   self		):



          '''simple docstring'''
          # visited array for storing already visited nodes
          lowerCAmelCase__   :Optional[int]      							=				[False] * len(self.vertex		)

          # call the recursive helper function
          for i in range(len(self.vertex		)		):
              if not visited[i]:
                  self.dfs_recursive(_lowerCAmelCase    ,	_lowerCAmelCase		)



      def 			snake_case_      (   self    ,	_lowerCAmelCase    ,	_lowerCAmelCase		):



          '''simple docstring'''
          # mark start vertex as visited
          lowerCAmelCase__   :Union[str, Any]      							=				True

          print(_lowerCAmelCase    ,	end=" "		)

          # Recur for all the vertices that are adjacent to this node
          for i in self.vertex:
              if not visited[i]:
                  self.dfs_recursive(_lowerCAmelCase    ,	_lowerCAmelCase		)


if __name__ == "__main__":
 _a    :   Any        =			Graph()
 g.add_edge(0, 1)
 g.add_edge(0, 2)
 g.add_edge(1, 2)
 g.add_edge(2, 0)
 g.add_edge(2, 3)
 g.add_edge(3, 3)

 g.print_graph()
 print("""DFS:""")
 g.dfs()

 # OUTPUT:
 # 0  ->  1 -> 2
 # 1  ->  2
 # 2  ->  0 -> 3
 # 3  ->  3
 # DFS:
 #  0 1 2 3











def 				snake_case__							(							UpperCAmelCase							:  Tuple       ):
    lowerCAmelCase__   :List[Any]      							=				len(UpperCAmelCase       )
    for i in range(length - 1       ):
        lowerCAmelCase__   :Union[str, Any]      							=				i
        for k in range(i + 1    ,			UpperCAmelCase       ):
            if collection[k] < collection[least]:
                lowerCAmelCase__   :Any      							=				k
        if least != i:
            lowerCAmelCase__							,lowerCAmelCase__   :int      							=				(collection[i], collection[least])
    return collection


if __name__ == "__main__":
 _a    :   Optional[int]        =			input("""Enter numbers separated by a comma:\n""").strip()
 _a    :   Any        =			[int(item) for item in user_input.split(""",""")]
 print(selection_sort(unsorted))



