





def   lowerCAmelCase_				( __a	)  ->	Tuple:







  """simple docstring"""





  stooge(__a			,					0			,					len(__a	) - 1	)
  return arr





def   lowerCAmelCase_				( __a			,					__a			,					__a	)  ->	int:







  """simple docstring"""





  if i >= h:
    return

  # If first element is smaller than the last then swap them
  if arr[i] > arr[h]:
    lowerCamelCase__:   List[str]    						=arr[h], arr[i]

  # If there are more than 2 elements in the array
  if h - i + 1 > 2:
    lowerCamelCase__:   Optional[int]    						=(int)((h - i + 1) / 3	)

    # Recursively sort first 2/3 elements
    stooge(__a			,					__a			,					(h - t)	)

    # Recursively sort last 2/3 elements
    stooge(__a			,					i + t			,					(__a)	)

    # Recursively sort first 2/3 elements
    stooge(__a			,					__a			,					(h - t)	)


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












def   lowerCAmelCase_				( __a	)  ->	str:







  """simple docstring"""





  lowerCamelCase__:   List[str]    						=""
  for ch in key:
    if ch == " " or ch not in key_no_dups and ch.isalpha():
      key_no_dups += ch
  return key_no_dups





def   lowerCAmelCase_				( __a	)  ->	dict[str, str]:







  """simple docstring"""





  lowerCamelCase__:   Dict    						=[chr(i + 65	) for i in range(26	)]
  # Remove duplicate characters from key
  lowerCamelCase__:   Union[str, Any]    						=remove_duplicates(key.upper()	)
  lowerCamelCase__:   List[Any]    						=len(__a	)
  # First fill cipher with key characters
  lowerCamelCase__:   Optional[Any]    						={alphabet[i]: char for i, char in enumerate(__a	)}
  # Then map remaining characters in alphabet to
  # the alphabet from the beginning
  for i in range(len(__a	)			,					26	):
    lowerCamelCase__:   Optional[int]    						=alphabet[i - offset]
    # Ensure we are not mapping letters to letters previously mapped
    while char in key:
      offset -= 1
      lowerCamelCase__:   List[Any]    						=alphabet[i - offset]
    lowerCamelCase__:   str    						=char
  return cipher_alphabet





def   lowerCAmelCase_				( __a			,					__a	)  ->	str:







  """simple docstring"""





  return "".join(cipher_map.get(__a			,					__a	) for ch in message.upper()	)





def   lowerCAmelCase_				( __a			,					__a	)  ->	str:







  """simple docstring"""





  lowerCamelCase__:   List[Any]    						={v: k for k, v in cipher_map.items()}
  return "".join(rev_cipher_map.get(__a			,					__a	) for ch in message.upper()	)





def   lowerCAmelCase_				( )  ->	None:







  """simple docstring"""





  lowerCamelCase__:   Optional[Any]    						=input("Enter message to encode or decode: "	).strip()
  lowerCamelCase__:   Dict    						=input("Enter keyword: "	).strip()
  lowerCamelCase__:   Any    						=input("Encipher or decipher? E/D:"	).strip()[0].lower()
  try:
    lowerCamelCase__:   Union[str, Any]    						={"e": encipher, "d": decipher}[option]
  except KeyError:
    raise KeyError("invalid input option"	)
  lowerCamelCase__:   List[Any]    						=create_cipher_map(__a	)
  print(func(__a			,					__a	)	)


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     main()

