


class 			lowerCamelCase_		:





				"""simple docstring"""







				def __init__(						self       ,		UpperCAmelCase__ = ""       ,		UpperCAmelCase__ = False     ):
								SCREAMING_SNAKE_CASE__     							=				{}

								# A node will be a leaf if the tree contains its word
								SCREAMING_SNAKE_CASE__     							=				is_leaf

								SCREAMING_SNAKE_CASE__     							=				prefix



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__     ):
								SCREAMING_SNAKE_CASE__     							=				0
								for q, w in zip(self.prefix       ,		_lowercase     ):
												if q != w:
																break

												x += 1

								return self.prefix[:x], self.prefix[x:], word[x:]



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__     ):

								for word in words:
												self.insert(_lowercase     )



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__     ):

								if self.prefix == word:
												SCREAMING_SNAKE_CASE__     							=				True

								# Case 2: The node has no edges that have a prefix to the word
								# Solution: We create an edge from the current node to a new one
								# containing the word
								elif word[0] not in self.nodes:
												SCREAMING_SNAKE_CASE__     							=				RadixNode(prefix=_lowercase       ,		is_leaf=_lowercase     )

								else:
												SCREAMING_SNAKE_CASE__     							=				self.nodes[word[0]]
												SCREAMING_SNAKE_CASE__     							=				incoming_node.match(
												    _lowercase     )

												# Case 3: The node prefix is equal to the matching
												# Solution: We insert remaining word on the next node
												if remaining_prefix == "":
																self.nodes[matching_string[0]].insert(_lowercase     )

												# Case 4: The word is greater equal to the matching
												# Solution: Create a node in between both nodes, change
												# prefixes and add the new node for the remaining word
												else:
																SCREAMING_SNAKE_CASE__     							=				remaining_prefix

																SCREAMING_SNAKE_CASE__     							=				self.nodes[matching_string[0]]
																SCREAMING_SNAKE_CASE__     							=				RadixNode(_lowercase       ,		_lowercase     )
																SCREAMING_SNAKE_CASE__     							=				aux_node

																if remaining_word == "":
																				SCREAMING_SNAKE_CASE__     							=				True
																else:
																				self.nodes[matching_string[0]].insert(_lowercase     )



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__     ):
								SCREAMING_SNAKE_CASE__     							=				self.nodes.get(word[0]       ,		_lowercase     )
								if not incoming_node:
												return False
								else:
												SCREAMING_SNAKE_CASE__     							=				incoming_node.match(
												    _lowercase     )
												# If there is remaining prefix, the word can't be on the tree
												if remaining_prefix != "":
																return False
												# This applies when the word and the prefix are equal
												elif remaining_word == "":
																return incoming_node.is_leaf
												# We have word remaining so we check the next node
												else:
																return incoming_node.find(_lowercase     )



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__     ):
								SCREAMING_SNAKE_CASE__     							=				self.nodes.get(word[0]       ,		_lowercase     )
								if not incoming_node:
												return False
								else:
												SCREAMING_SNAKE_CASE__     							=				incoming_node.match(
												    _lowercase     )
												# If there is remaining prefix, the word can't be on the tree
												if remaining_prefix != "":
																return False
												# We have word remaining so we check the next node
												elif remaining_word != "":
																return incoming_node.delete(_lowercase     )
												else:
																# If it is not a leaf, we don't have to delete
																if not incoming_node.is_leaf:
																				return False
																else:
																				# We delete the nodes if no edges go from it
																				if len(incoming_node.nodes     ) == 0:
																								del self.nodes[word[0]]
																								# We merge the current node with its only child
																								if len(self.nodes     ) == 1 and not self.is_leaf:
																												SCREAMING_SNAKE_CASE__     							=				list(self.nodes.values()     )[0]
																												SCREAMING_SNAKE_CASE__     							=				merging_node.is_leaf
																												self.prefix += merging_node.prefix
																												SCREAMING_SNAKE_CASE__     							=				merging_node.nodes
                    # If there is more than 1 edge, we just mark it as non-leaf
																				elif len(incoming_node.nodes     ) > 1:
																								SCREAMING_SNAKE_CASE__     							=				False
																				# If there is 1 edge, we merge it with its child
																				else:
																								SCREAMING_SNAKE_CASE__     							=				list(incoming_node.nodes.values()     )[0]
																								SCREAMING_SNAKE_CASE__     							=				merging_node.is_leaf
																								incoming_node.prefix += merging_node.prefix
																								SCREAMING_SNAKE_CASE__     							=				merging_node.nodes

																				return True






				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__ = 0     ):

								if self.prefix != "":
												print("-" * height       ,		self.prefix       ,		"  (leaf)" if self.is_leaf else ""     )

								for value in self.nodes.values():
												value.print_tree(height + 1     )


def __lowercase     (      ):
				SCREAMING_SNAKE_CASE__     							=				"""banana bananas bandana band apple all beast""".split()
				SCREAMING_SNAKE_CASE__     							=				RadixNode()
				root.insert_many(__UpperCamelCase  )

				assert all(root.find(__UpperCamelCase  ) for word in words  )
				assert not root.find("bandanas"  )
				assert not root.find("apps"  )
				root.delete("all"  )
				assert not root.find("all"  )
				root.delete("banana"  )
				assert not root.find("banana"  )
				assert root.find("bananas"  )

				return True


def __lowercase     (      ):
				assert test_trie()


def __lowercase     (      ):
				SCREAMING_SNAKE_CASE__     							=				RadixNode()
				SCREAMING_SNAKE_CASE__     							=				"""banana bananas bandanas bandana band apple all beast""".split()
				root.insert_many(__UpperCamelCase  )

				print("Words:"						,					__UpperCamelCase  )
				print("Tree:"  )
				root.print_tree()


if __name__ == "__main__":
	main()




"""simple docstring"""






from __future__ import annotations


def __lowercase     (      lowerCamelCase_  :      list						,					lowerCamelCase_  :      int						,					lowerCamelCase_  :      int						,					lowerCamelCase_  :      int  ):
				SCREAMING_SNAKE_CASE__     							=				[]
				SCREAMING_SNAKE_CASE__							,      SCREAMING_SNAKE_CASE__     							=				input_list[low:mid], input_list[mid : high + 1]
				while left and right:
								result.append((left if left[0] <= right[0] else right).pop(0  )  )
				SCREAMING_SNAKE_CASE__     							=				result + left + right
				return input_list


def __lowercase     (      lowerCamelCase_  :      list  ):
				if len(lowerCamelCase_  ) <= 1:
								return input_list
				SCREAMING_SNAKE_CASE__     							=				list(lowerCamelCase_  )

				# iteration for two-way merging
				SCREAMING_SNAKE_CASE__     							=				2
				while p <= len(lowerCamelCase_  ):
								# getting low, high and middle value for merge-sort of single list
								for i in range(0						,					len(lowerCamelCase_  )						,					lowerCamelCase_  ):
												SCREAMING_SNAKE_CASE__     							=				i
												SCREAMING_SNAKE_CASE__     							=				i + p - 1
												SCREAMING_SNAKE_CASE__     							=				(low + high + 1) // 2
												SCREAMING_SNAKE_CASE__     							=				merge(lowerCamelCase_						,					lowerCamelCase_						,					lowerCamelCase_						,					lowerCamelCase_  )
								# final merge of last two parts
								if p * 2 >= len(lowerCamelCase_  ):
												SCREAMING_SNAKE_CASE__     							=				i
												SCREAMING_SNAKE_CASE__     							=				merge(lowerCamelCase_						,					0						,					lowerCamelCase_						,					len(lowerCamelCase_  ) - 1  )
												break
								p *= 2

				return input_list


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