






"""simple docstring"""





from __future__ import annotations

from typing import Generic, TypeVar

A__					: Any=	TypeVar("""T""")
class    __lowerCamelCase    (  Generic[T]  ):

   def __init__(					self ,				snake_case_      )		->       None:
       UpperCamelCase__         =    data
       UpperCamelCase__         =    self
       UpperCamelCase__         =    0







class    __lowerCamelCase    (  Generic[T]  ):

   def __init__(					self      )		->       None:
       # map from node name to the node object
       UpperCamelCase__         =    {}

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_      )		->       None:
       # create a new set with x as its member
       UpperCamelCase__         =    DisjointSetTreeNode(snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_      )		->       DisjointSetTreeNode[T]:
       # find the set x belongs to (with path-compression)
       UpperCamelCase__         =    self.map[data]
       if elem_ref != elem_ref.parent:
           UpperCamelCase__         =    self.find_set(elem_ref.parent.data      )
       return elem_ref.parent

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_      )		->       None:
       # helper function for union operation
       if nodea.rank > nodea.rank:
           UpperCamelCase__         =    nodea
       else:
           UpperCamelCase__         =    nodea
           if nodea.rank == nodea.rank:
               nodea.rank += 1







   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_      )		->       None:
       # merge 2 disjoint sets
       self.link(self.find_set(snake_case_      ) ,				self.find_set(snake_case_      )      )







class    __lowerCamelCase    (  Generic[T]  ):

   def __init__(					self      )		->       None:
       # connections: map from the node to the neighbouring nodes (with weights)
       UpperCamelCase__         =    {}

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_      )		->       None:
       # add a node ONLY if its not present in the graph
       if node not in self.connections:
           UpperCamelCase__         =    {}

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       None:
       # add an edge with the given weight
       self.add_node(snake_case_      )
       self.add_node(snake_case_      )
       UpperCamelCase__         =    weight
       UpperCamelCase__         =    weight







   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       GraphUndirectedWeighted[T]:
       UpperCamelCase__         =    []
       UpperCamelCase__         =    set()
       for start in self.connections:
           for end in self.connections[start]:
               if (start, end) not in seen:
                   seen.add((end, start)      )
                   edges.append((start, end, self.connections[start][end])      )
       edges.sort(key=lambda snake_case_      : x[2]      )

       # creating the disjoint set
       UpperCamelCase__         =    DisjointSetTree[T]()
       for node in self.connections:
           disjoint_set.make_set(snake_case_      )

       # MST generation
       UpperCamelCase__         =    0
       UpperCamelCase__         =    0
       UpperCamelCase__         =    GraphUndirectedWeighted[T]()
       while num_edges < len(self.connections      ) - 1:
           UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__         =    edges[index]
           index += 1
           UpperCamelCase__         =    disjoint_set.find_set(snake_case_      )
           UpperCamelCase__         =    disjoint_set.find_set(snake_case_      )
           if parent_u != parent_v:
               num_edges += 1
               graph.add_edge(snake_case_ ,				snake_case_ ,				snake_case_      )
               disjoint_set.union(snake_case_ ,				snake_case_      )
       return graph












"""simple docstring"""





def   lowerCAmelCase_( SCREAMING_SNAKE_CASE					)					->	list[int]:
    """simple docstring"""

    UpperCamelCase__         =    len(SCREAMING_SNAKE_CASE					)
    for i in range(SCREAMING_SNAKE_CASE					):
        for j in range(i + 1 ,	SCREAMING_SNAKE_CASE					):
            if numbers[j] < numbers[i]:
                UpperCamelCase__       ,						UpperCamelCase__         =    numbers[j], numbers[i]
    return numbers


if __name__ == "__main__":
  A__					: Union[str, Any]=	input("""Enter numbers separated by a comma:\n""").strip()
  A__					: List[Any]=	[int(item) for item in user_input.split(""",""")]
  print(exchange_sort(unsorted))




