'''simple docstring'''


def       lowerCAmelCase					(		UpperCamelCase__				:   Any       ):


	"""simple docstring"""
	return [
	    {
	        0: [1, 2],
	        1: [0, 2],
	        2: [0, 1, 3, 5],
	        3: [2, 4],
	        4: [3],
	        5: [2, 6, 8],
	        6: [5, 7],
	        7: [6, 8],
	        8: [5, 7],
	    },
	    {
	        0: [6],
	        1: [9],
	        2: [4, 5],
	        3: [4],
	        4: [2, 3],
	        5: [2],
	        6: [0, 7],
	        7: [6],
	        8: [],
	        9: [1],
	    },
	    {
	        0: [4],
	        1: [6],
	        2: [],
	        3: [5, 6, 7],
	        4: [0, 6],
	        5: [3, 8, 9],
	        6: [1, 3, 4, 7],
	        7: [3, 6, 8, 9],
	        8: [5, 7],
	        9: [5, 7],
	    },
	    {
	        0: [1, 3],
	        1: [0, 2, 4],
	        2: [1, 3, 4],
	        3: [0, 2, 4],
	        4: [1, 2, 3],
	    },
	][index]





def       lowerCAmelCase					(		UpperCamelCase__				:   dict[int, list[int]]       ):


	"""simple docstring"""
	__UpperCAmelCase							=			0
	__UpperCAmelCase							=			len(UpperCamelCase__       )  # No of vertices in graph
	__UpperCAmelCase							=			[0] * n
	__UpperCAmelCase							=			[False] * n

	def dfs(UpperCamelCase__				:   Dict    ,					UpperCamelCase__				:   Union[str, Any]    ,					UpperCamelCase__				:   Tuple    ,					UpperCamelCase__				:   List[str]       ):
		__UpperCAmelCase							=			True
		__UpperCAmelCase							=			id_
		id_ += 1
		for to in graph[at]:
			if to == parent:
				pass
			elif not visited[to]:
				dfs(UpperCamelCase__    ,					UpperCamelCase__    ,					UpperCamelCase__    ,					id_       )
				__UpperCAmelCase							=			min(low[at]    ,					low[to]       )
				if id_ <= low[to]:
					bridges.append((at, to) if at < to else (to, at)       )
			else:
				# This edge is a back edge and cannot be a bridge
				__UpperCAmelCase							=			min(low[at]    ,					low[to]       )

	__UpperCAmelCase							=			[]
	for i in range(UpperCamelCase__       ):
		if not visited[i]:
			dfs(UpperCamelCase__    ,					-1    ,					UpperCamelCase__    ,					id_       )
	return bridges


if __name__ == "__main__":
					import doctest

					doctest.testmod()

'''simple docstring'''


def       lowerCAmelCase					(		UpperCamelCase__				:   Tuple       ):


	"""simple docstring"""
	# if the collection is empty, returns empty
	if collection == []:
		return []

	# get some information about the collection
	__UpperCAmelCase							=			len(UpperCamelCase__       )
	__UpperCAmelCase							=			max(UpperCamelCase__       )
	__UpperCAmelCase							=			min(UpperCamelCase__       )

	# create the counting array
	__UpperCAmelCase							=			coll_max + 1 - coll_min
	__UpperCAmelCase							=			[0] * counting_arr_length

	# count how much a number appears in the collection
	for number in collection:
		counting_arr[number - coll_min] += 1

	# sum each position with it's predecessors. now, counting_arr[i] tells
	# us how many elements <= i has in the collection
	for i in range(1    ,					UpperCamelCase__       ):
		__UpperCAmelCase							=			counting_arr[i] + counting_arr[i - 1]

	# create the output collection
	__UpperCAmelCase							=			[0] * coll_len

	# place the elements in the output, respecting the original order (stable
	# sort) from end to begin, updating counting_arr
	for i in reversed(range(0    ,					UpperCamelCase__       )       ):
		__UpperCAmelCase							=			collection[i]
		counting_arr[collection[i] - coll_min] -= 1

	return ordered





def       lowerCAmelCase					(		UpperCamelCase__				:   Any       ):


	"""simple docstring"""
	return "".join([chr(UpperCamelCase__       ) for i in counting_sort([ord(UpperCamelCase__       ) for c in string]       )]       )


if __name__ == "__main__":
					# Test string sort
					assert counting_sort_string("thisisthestring") == "eghhiiinrsssttt"

					__lowerCAmelCase	:       str						       =	input("Enter numbers separated by a comma:\n").strip()
					__lowerCAmelCase	:       List[Any]						       =	[int(item) for item in user_input.split(",")]
					print(counting_sort(unsorted))
