UpperCamelCase      			=     {
    'A': ('ABCDEFGHIJKLM', 'NOPQRSTUVWXYZ'),
    'B': ('ABCDEFGHIJKLM', 'NOPQRSTUVWXYZ'),
    'C': ('ABCDEFGHIJKLM', 'ZNOPQRSTUVWXY'),
    'D': ('ABCDEFGHIJKLM', 'ZNOPQRSTUVWXY'),
    'E': ('ABCDEFGHIJKLM', 'YZNOPQRSTUVWX'),
    'F': ('ABCDEFGHIJKLM', 'YZNOPQRSTUVWX'),
    'G': ('ABCDEFGHIJKLM', 'XYZNOPQRSTUVW'),
    'H': ('ABCDEFGHIJKLM', 'XYZNOPQRSTUVW'),
    'I': ('ABCDEFGHIJKLM', 'WXYZNOPQRSTUV'),
    'J': ('ABCDEFGHIJKLM', 'WXYZNOPQRSTUV'),
    'K': ('ABCDEFGHIJKLM', 'VWXYZNOPQRSTU'),
    'L': ('ABCDEFGHIJKLM', 'VWXYZNOPQRSTU'),
    'M': ('ABCDEFGHIJKLM', 'UVWXYZNOPQRST'),
    'N': ('ABCDEFGHIJKLM', 'UVWXYZNOPQRST'),
    'O': ('ABCDEFGHIJKLM', 'TUVWXYZNOPQRS'),
    'P': ('ABCDEFGHIJKLM', 'TUVWXYZNOPQRS'),
    'Q': ('ABCDEFGHIJKLM', 'STUVWXYZNOPQR'),
    'R': ('ABCDEFGHIJKLM', 'STUVWXYZNOPQR'),
    'S': ('ABCDEFGHIJKLM', 'RSTUVWXYZNOPQ'),
    'T': ('ABCDEFGHIJKLM', 'RSTUVWXYZNOPQ'),
    'U': ('ABCDEFGHIJKLM', 'QRSTUVWXYZNOP'),
    'V': ('ABCDEFGHIJKLM', 'QRSTUVWXYZNOP'),
    'W': ('ABCDEFGHIJKLM', 'PQRSTUVWXYZNO'),
    'X': ('ABCDEFGHIJKLM', 'PQRSTUVWXYZNO'),
    'Y': ('ABCDEFGHIJKLM', 'OPQRSTUVWXYZN'),
    'Z': ('ABCDEFGHIJKLM', 'OPQRSTUVWXYZN'),
}



def    lowerCamelCase_   (  _lowercase    )							->	list[tuple[str, str]]:
		return [alphabet[char] for char in key.upper()]



def    lowerCamelCase_   (  _lowercase ,     _lowercase    )							->	str:
		__A							:   Optional[Any]	  =				""
		__A							:   Tuple	  =				0
		__A							:   List[str]	  =				generate_table(_lowercase    )
		for char in words.upper():
				cipher += get_opponent(table[count] ,     _lowercase    )
				__A							:   List[Any]	  =				(count + 1) % len(_lowercase    )
		return cipher



def    lowerCamelCase_   (  _lowercase ,     _lowercase    )							->	str:
		return encrypt(_lowercase ,     _lowercase    )



def    lowerCamelCase_   (  _lowercase ,     _lowercase    )							->	tuple[int, int]:
		__A							:   List[Any]	  =				0 if char in table[0] else 1
		__A							:   List[str]	  =				table[row].index(_lowercase    )
		return row, col



def    lowerCamelCase_   (  _lowercase ,     _lowercase    )							->	str:
		__A  ,       __A							:   Tuple	  =				get_position(_lowercase ,     char.upper()    )
		if row == 1:
				return table[0][col]
		else:
				return table[1][col] if row == 0 else char


if __name__ == "__main__":
					import doctest

					doctest.testmod()  # Fist ensure that all our tests are passing...
					UpperCamelCase      			=     input('Enter key: ').strip()
					UpperCamelCase      			=     input('Enter text to encrypt: ').strip()
					UpperCamelCase      			=     encrypt(key, text)

					print(F'''Encrypted: {cipher_text}''')
					print(F'''Decrypted with key: {decrypt(key, cipher_text)}''')






def    lowerCamelCase_   (  _lowercase ,     _lowercase ,     _lowercase    )							->	Tuple:
		__A							:   Union[str, Any]	  =				index
		__A							:   int	  =				2 * index + 1
		__A							:   Dict	  =				2 * index + 2
		if left_index < heap_size and unsorted[left_index] > unsorted[largest]:
				__A							:   Dict	  =				left_index

		if right_index < heap_size and unsorted[right_index] > unsorted[largest]:
				__A							:   int	  =				right_index

		if largest != index:
				__A  ,       __A							:   Dict	  =				unsorted[index], unsorted[largest]
				heapify(_lowercase ,     _lowercase ,     _lowercase    )



def    lowerCamelCase_   (  _lowercase    )							->	Tuple:
		__A							:   Dict	  =				len(_lowercase    )
		for i in range(n // 2 - 1 ,     -1 ,     -1    ):
				heapify(_lowercase ,     _lowercase ,     _lowercase    )
		for i in range(n - 1 ,     0 ,     -1    ):
				__A  ,       __A							:   Dict	  =				unsorted[i], unsorted[0]
				heapify(_lowercase ,     0 ,     _lowercase    )
		return unsorted


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





