




from __future__ import annotations

import random
import string



class       lowercase_		:



						def __init__( self  :      str				,       snake_case__  :      str | None = None     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       passcode or self.__passcode_creator()
								SCREAMING_SNAKE_CASE_							=       self.__make_key_list()
								SCREAMING_SNAKE_CASE_							=       self.__make_shift_key()



						def __str__( self  :      List[Any]     ):

								"""simple docstring"""

								return "".join(self.__passcode     )



						def   __a				( self  :      Union[str, Any]				,       snake_case__  :      list[int]     ):

								"""simple docstring"""

								for i in range(1				,       len(snake_case__     )				,       2     ):
										iterlist[i] *= -1
								return iterlist



						def   __a				( self  :      str     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       string.ascii_letters + string.digits
								SCREAMING_SNAKE_CASE_							=       [random.choice(snake_case__     ) for _ in range(random.randint(10				,       20     )     )]
								return password



						def   __a				( self  :      str     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       (
								    string.ascii_letters + string.digits + string.punctuation + ' \t\n'
								)

								SCREAMING_SNAKE_CASE_							=       []

								# creates points known as breakpoints to break the key_list_options at those
								# points and pivot each substring
								SCREAMING_SNAKE_CASE_							=       sorted(set(self.__passcode     )     )
								SCREAMING_SNAKE_CASE_							=       []

								# algorithm for creating a new shuffled list, keys_l, out of key_list_options
								for i in key_list_options:
										temp_list.extend(snake_case__     )

										# checking breakpoints at which to pivot temporary sublist and add it into
										# keys_l
										if i in breakpoints or i == key_list_options[-1]:
												keys_l.extend(temp_list[::-1]     )
												temp_list.clear()

        # returning a shuffled keys_l to prevent brute force guessing of shift key
								return keys_l



						def   __a				( self  :      Union[str, Any]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       sum(self.__neg_pos([ord(snake_case__     ) for x in self.__passcode]     )     )
								return num if num > 0 else len(self.__passcode     )



						def   __a				( self  :      str				,       snake_case__  :      str     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       ''

								# decoding shift like Caesar cipher algorithm implementing negative shift or
								# reverse shift or left shift
								for i in encoded_message:
										SCREAMING_SNAKE_CASE_							=       self.__key_list.index(snake_case__     )
										decoded_message += self.__key_list[
										    (position - self.__shift_key) % -len(self.__key_list     )
										]

								return decoded_message






						def   __a				( self  :      Optional[int]				,       snake_case__  :      str     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       ''

								# encoding shift like Caesar cipher algorithm implementing positive shift or
								# forward shift or right shift
								for i in plaintext:
										SCREAMING_SNAKE_CASE_							=       self.__key_list.index(snake_case__     )
										encoded_message += self.__key_list[
										    (position + self.__shift_key) % len(self.__key_list     )
										]

								return encoded_message


def 				_a       (				lowerCAmelCase = "Hello, this is a modified Caesar cipher"   )->  str:
		SCREAMING_SNAKE_CASE_							=       ShuffledShiftCipher()
		return cipa.decrypt(cipa.encrypt(lowerCAmelCase   )   )


if __name__ == "__main__":
						import doctest

						doctest.testmod()





from __future__ import annotations


def 				_a       (				lowerCAmelCase						,	lowerCAmelCase   )->  Union[str, Any]:
		SCREAMING_SNAKE_CASE_							=       0
		SCREAMING_SNAKE_CASE_							=       len(lowerCAmelCase   ) - 1
		while left <= right:
				SCREAMING_SNAKE_CASE_							=       (left + right) // 2
				if left == right:
						if sorted_list[middle] < item:
								SCREAMING_SNAKE_CASE_							=       middle + 1
						break
				elif sorted_list[middle] < item:
						SCREAMING_SNAKE_CASE_							=       middle + 1
				else:
						SCREAMING_SNAKE_CASE_							=       middle - 1
		sorted_list.insert(lowerCAmelCase						,	lowerCAmelCase   )
		return sorted_list


def 				_a       (				lowerCAmelCase						,	lowerCAmelCase   )->  Any:
		SCREAMING_SNAKE_CASE_							=       []
		while left and right:
				if left[0][0] < right[0][0]:
						result.append(left.pop(0   )   )
				else:
						result.append(right.pop(0   )   )
		return result + left + right


def 				_a       (				lowerCAmelCase   )->  List[str]:
		SCREAMING_SNAKE_CASE_							=       len(lowerCAmelCase   )
		if length <= 1:
				return list_ad
		SCREAMING_SNAKE_CASE_							=       length // 2
		return merge(sortlist_ad(list_ad[:middle]   )						,	sortlist_ad(list_ad[middle:]   )   )


def 				_a       (				lowerCAmelCase   )->  list[int]:

		if len(lowerCAmelCase   ) <= 1:
				return collection
		SCREAMING_SNAKE_CASE_							=       []
		SCREAMING_SNAKE_CASE_							=       False
		for i in range(0						,	len(lowerCAmelCase   )						,	2   ):
				if i == len(lowerCAmelCase   ) - 1:
						SCREAMING_SNAKE_CASE_							=       True
				else:
						if collection[i] < collection[i + 1]:
								two_paired_list.append([collection[i], collection[i + 1]]   )
						else:
								two_paired_list.append([collection[i + 1], collection[i]]   )
		SCREAMING_SNAKE_CASE_							=       sortlist_ad(lowerCAmelCase   )
		SCREAMING_SNAKE_CASE_							=       [i[0] for i in sorted_list_ad]
		result.append(sorted_list_ad[-1][1]   )
		if has_last_odd_item:
				SCREAMING_SNAKE_CASE_							=       collection[-1]
				SCREAMING_SNAKE_CASE_							=       binary_search_insertion(lowerCAmelCase						,	lowerCAmelCase   )
		SCREAMING_SNAKE_CASE_							=       False
		for i in range(len(lowerCAmelCase   ) - 1   ):
				if result[i] == collection[-1] and has_last_odd_item:
						SCREAMING_SNAKE_CASE_							=       True
				SCREAMING_SNAKE_CASE_							=       sorted_list_ad[i][1]
				# If last_odd_item is inserted before the item's index,
				# you should forward index one more.
				if is_last_odd_item_inserted_before_this_index:
						SCREAMING_SNAKE_CASE_							=       result[: i + 2] + binary_search_insertion(result[i + 2 :]						,	lowerCAmelCase   )
				else:
						SCREAMING_SNAKE_CASE_							=       result[: i + 1] + binary_search_insertion(result[i + 1 :]						,	lowerCAmelCase   )

		return result


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