





# using dfs for finding eulerian path traversal


def 							SCREAMING_SNAKE_CASE__       (  snake_case__  :Any			,							snake_case__  :List[Any]			,							snake_case__  :Optional[int]			,							snake_case__  :int=None     )      ->						str:
		_lowercase							= (path or []) + [u]
		for v in graph[u]:
				if visited_edge[u][v] is False:
						_lowercase						,		_lowercase							= True, True
						_lowercase							= dfs(snake_case__			,							snake_case__			,							snake_case__			,							snake_case__     )
		return path

def 							SCREAMING_SNAKE_CASE__       (  snake_case__  :int			,							snake_case__  :Any     )      ->						Tuple:
		_lowercase							= 0
		_lowercase							= -1
		for i in range(snake_case__     ):
				if i not in graph.keys():
						continue
				if len(graph[i]     ) % 2 == 1:
						odd_degree_nodes += 1
						_lowercase							= i
		if odd_degree_nodes == 0:
				return 1, odd_node
		if odd_degree_nodes == 2:
				return 2, odd_node
		return 3, odd_node

def 							SCREAMING_SNAKE_CASE__       (  snake_case__  :List[str]			,							snake_case__  :List[str]     )      ->						int:
		_lowercase							= [[False for _ in range(max_node + 1     )] for _ in range(max_node + 1     )]
		_lowercase						,		_lowercase							= check_circuit_or_path(snake_case__			,							snake_case__     )
		if check == 3:
				print('graph is not Eulerian'     )
				print('no path'     )
				return
		_lowercase							= 1
		if check == 2:
				_lowercase							= odd_node
				print('graph has a Euler path'     )
		if check == 1:
				print('graph has a Euler cycle'     )
		_lowercase							= dfs(snake_case__			,							snake_case__			,							snake_case__     )
		print(snake_case__     )

def 							SCREAMING_SNAKE_CASE__       (  )      ->						Tuple:
		_lowercase							= {1: [2, 3, 4], 2: [1, 3], 3: [1, 2], 4: [1, 5], 5: [4]}
		_lowercase							= {1: [2, 3, 4, 5], 2: [1, 3], 3: [1, 2], 4: [1, 5], 5: [1, 4]}
		_lowercase							= {1: [2, 3, 4], 2: [1, 3, 4], 3: [1, 2], 4: [1, 2, 5], 5: [4]}
		_lowercase							= {1: [2, 3], 2: [1, 3], 3: [1, 2]}
		_lowercase							= {
		    1: [],
		    2: []
		    # all degree is zero
		}
		_lowercase							= 10
		check_euler(snake_case__			,							snake_case__     )
		check_euler(snake_case__			,							snake_case__     )
		check_euler(snake_case__			,							snake_case__     )
		check_euler(snake_case__			,							snake_case__     )
		check_euler(snake_case__			,							snake_case__     )


if __name__ == "__main__":
						main()






def 							SCREAMING_SNAKE_CASE__       (  snake_case__  :List[str]     )      ->						Dict:
  _lowercase							= len(snake_case__     )
  while cur > 1:
    # Find the maximum number in arr
    _lowercase							= arr.index(max(arr[0:cur]     )     )
    # Reverse from 0 to mi
    _lowercase							= arr[mi::-1] + arr[mi + 1 : len(snake_case__     )]
    # Reverse whole list
    _lowercase							= arr[cur - 1 :: -1] + arr[cur : len(snake_case__     )]
    cur -= 1
  return arr


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