




def 	_a      (						SCREAMING_SNAKE_CASE_							:				list     ):

					if len(SCREAMING_SNAKE_CASE_     ) <= 1:
										return [tuple(SCREAMING_SNAKE_CASE_     )]

					__lowerCAmelCase				   =       []

					def generate(SCREAMING_SNAKE_CASE_							:				int      ,      SCREAMING_SNAKE_CASE_							:				list     ):
										if k == 1:
															res.append(tuple(arr[:]     )     )
															return

										generate(k - 1      ,      SCREAMING_SNAKE_CASE_     )

										for i in range(k - 1     ):
															if k % 2 == 0:  # k is even
																				__lowerCAmelCase   ,							__lowerCAmelCase				   =       arr[k - 1], arr[i]
															else:  # k is odd
																				__lowerCAmelCase   ,							__lowerCAmelCase				   =       arr[k - 1], arr[0]
															generate(k - 1      ,      SCREAMING_SNAKE_CASE_     )

					generate(len(SCREAMING_SNAKE_CASE_     )      ,      SCREAMING_SNAKE_CASE_     )
					return res


if __name__ == "__main__":
					UpperCamelCase__    			=			input("""Enter numbers separated by a comma:\n""").strip()
					UpperCamelCase__    			=			[int(item) for item in user_input.split(""",""")]
					print(heaps(arr))









'''simple docstring'''






class 							lowercase       :


 """simple docstring"""


 def __init__(							self							)		->   List[str]:
        _UpperCAmelCase  :						int			     = 0
        _UpperCAmelCase  :						Union[str, Any]			     = 0
        _UpperCAmelCase  :						Optional[int]			     = {}







 def _snake_case (							self  ,a_							)		->   Optional[Any]:
        if vertex not in self.adjacency:
               _UpperCAmelCase  :						int			     = {}
               self.num_vertices += 1







 def _snake_case (							self  ,a_  ,a_  ,a_							)		->   int:
        self.add_vertex(a_							)
        self.add_vertex(a_							)

        if head == tail:
               return

        _UpperCAmelCase  :						List[Any]			     = weight
        _UpperCAmelCase  :						Dict			     = weight







 def _snake_case (							self							)		->   Dict:
        _UpperCAmelCase  :						Optional[int]			     = self.get_edges()
        for edge in edges:
               _UpperCAmelCase     ,_UpperCAmelCase     ,_UpperCAmelCase  :						Dict			     = edge
               edges.remove((tail, head, weight)							)
        for i in range(len(a_							)							):
               _UpperCAmelCase  :						str			     = list(edges[i]							)

        edges.sort(key=lambda a_							: e[2]							)
        for i in range(len(a_							) - 1							):
               if edges[i][2] >= edges[i + 1][2]:
                      _UpperCAmelCase  :						Optional[Any]			     = edges[i][2] + 1
        for edge in edges:
               _UpperCAmelCase     ,_UpperCAmelCase     ,_UpperCAmelCase  :						Union[str, Any]			     = edge
               _UpperCAmelCase  :						str			     = weight
               _UpperCAmelCase  :						List[str]			     = weight







 def __str__(							self							)		->   Any:
        _UpperCAmelCase  :						List[Any]			     = """"""
        for tail in self.adjacency:
               for head in self.adjacency[tail]:
                      _UpperCAmelCase  :						List[str]			     = self.adjacency[head][tail]
                      string += f'''{head} -> {tail} == {weight}\n'''
        return string.rstrip("""\n"""							)







 def _snake_case (							self							)		->   str:
        _UpperCAmelCase  :						int			     = []
        for tail in self.adjacency:
               for head in self.adjacency[tail]:
                      output.append((tail, head, self.adjacency[head][tail])							)
        return output







 def _snake_case (							self							)		->   Optional[int]:
        return self.adjacency.keys()







 @staticmethod
 def _snake_case (							a_=None  ,a_=None							)		->   Tuple:
        _UpperCAmelCase  :						List[Any]			     = Graph()
        if vertices is None:
               _UpperCAmelCase  :						List[str]			     = []
        if edges is None:
               _UpperCAmelCase  :						Optional[Any]			     = []
        for vertex in vertices:
               g.add_vertex(a_							)
        for edge in edges:
               g.add_edge(*a_							)
        return g



 class 							lowercase       :


  """simple docstring"""


  def __init__(							self							)		->   int:
         _UpperCAmelCase  :						List[str]			     = {}
         _UpperCAmelCase  :						int			     = {}







  def __len__(							self							)		->   Tuple:
         return len(self.parent							)







  def _snake_case (							self  ,a_							)		->   str:
         if item in self.parent:
                return self.find(a_							)

         _UpperCAmelCase  :						Optional[Any]			     = item
         _UpperCAmelCase  :						List[Any]			     = 0
         return item







  def _snake_case (							self  ,a_							)		->   List[str]:
         if item not in self.parent:
                return self.make_set(a_							)
         if item != self.parent[item]:
                _UpperCAmelCase  :						List[Any]			     = self.find(self.parent[item]							)
         return self.parent[item]







  def _snake_case (							self  ,a_  ,a_							)		->   Union[str, Any]:
         _UpperCAmelCase  :						Any			     = self.find(a_							)
         _UpperCAmelCase  :						List[str]			     = self.find(a_							)

         if roota == roota:
                return roota

         if self.rank[roota] > self.rank[roota]:
                _UpperCAmelCase  :						Any			     = roota
                return roota

         if self.rank[roota] < self.rank[roota]:
                _UpperCAmelCase  :						Any			     = roota
                return roota

         if self.rank[roota] == self.rank[roota]:
                self.rank[roota] += 1
                _UpperCAmelCase  :						List[str]			     = roota
                return roota
         return None







 @staticmethod
 def _snake_case (							a_							)		->   List[Any]:
        _UpperCAmelCase  :						int			     = graph.num_vertices

        _UpperCAmelCase  :						int			     = Graph.UnionFind()
        _UpperCAmelCase  :						Optional[int]			     = []
        while num_components > 1:
               _UpperCAmelCase  :						int			     = {}
               for vertex in graph.get_vertices():
                      _UpperCAmelCase  :						Union[str, Any]			     = -1

               _UpperCAmelCase  :						Tuple			     = graph.get_edges()
               for edge in edges:
                      _UpperCAmelCase     ,_UpperCAmelCase     ,_UpperCAmelCase  :						str			     = edge
                      edges.remove((tail, head, weight)							)
               for edge in edges:
                      _UpperCAmelCase     ,_UpperCAmelCase     ,_UpperCAmelCase  :						Optional[Any]			     = edge
                      _UpperCAmelCase  :						Any			     = union_find.find(a_							)
                      _UpperCAmelCase  :						Any			     = union_find.find(a_							)
                      if seta != seta:
                             if cheap_edge[seta] == -1 or cheap_edge[seta][2] > weight:
                                    _UpperCAmelCase  :						Tuple			     = [head, tail, weight]

                             if cheap_edge[seta] == -1 or cheap_edge[seta][2] > weight:
                                    _UpperCAmelCase  :						List[str]			     = [head, tail, weight]
               for vertex in cheap_edge:
                      if cheap_edge[vertex] != -1:
                             _UpperCAmelCase     ,_UpperCAmelCase     ,_UpperCAmelCase  :						str			     = cheap_edge[vertex]
                             if union_find.find(a_							) != union_find.find(a_							):
                                    union_find.union(a_  ,a_							)
                                    mst_edges.append(cheap_edge[vertex]							)
                                    _UpperCAmelCase  :						Tuple			     = num_components - 1
        _UpperCAmelCase  :						Optional[int]			     = Graph.build(edges=a_							)
        return mst



