'''simple docstring'''

def lowerCamelCase__						(       A_       ):
 # base case
 if len(A_       ) == 1:
  return a[0], a[0]
 else:
  # split A into half.
  UpperCAmelCase_				       =					a[: len(A_       ) // 2]
  UpperCAmelCase_				       =					a[len(A_       ) // 2 :]

  # 2 sub problems, 1/2 of original size.
  UpperCAmelCase_       ,       UpperCAmelCase_				       =					max_difference(A_       )
  UpperCAmelCase_       ,       UpperCAmelCase_				       =					max_difference(A_       )

  # get min of first and max of second
  # linear time
  UpperCAmelCase_				       =					min(A_       )
  UpperCAmelCase_				       =					max(A_       )

  # 3 cases, either (small1, big1),
  # (min_first, max_second), (small2, big2)
  # constant comparisons
  if biga - smalla > max_second - min_first and biga - smalla > biga - smalla:
   return smalla, biga
  elif biga - smalla > max_second - min_first:
   return smalla, biga
  else:
   return min_first, max_second


if __name__ == "__main__":
      import doctest

      doctest.testmod()

'''simple docstring'''

import random
import sys

__snake_case       :   str  		=    '''ABCDEFGHIJKLMNOPQRSTUVWXYZ'''



def lowerCamelCase__						(       ):
 UpperCAmelCase_				       =					input("Enter message: "       )
 UpperCAmelCase_				       =					"LFWOAYUISVKMNXPBDCRJTQEGHZ"
 UpperCAmelCase_				       =					input("Encrypt/Decrypt [e/d]: "       )

 check_valid_key(A_       )

 if resp.lower().startswith("e"       ):
  UpperCAmelCase_				       =					"encrypt"
  UpperCAmelCase_				       =					encrypt_message(A_       ,			A_       )
 elif resp.lower().startswith("d"       ):
  UpperCAmelCase_				       =					"decrypt"
  UpperCAmelCase_				       =					decrypt_message(A_       ,			A_       )

 print(F"""\n{mode.title()}ion: \n{translated}"""       )



def lowerCamelCase__						(       A_       ):
 UpperCAmelCase_				       =					list(A_       )
 UpperCAmelCase_				       =					list(A_       )
 key_list.sort()
 letters_list.sort()

 if key_list != letters_list:
  sys.exit("Error in the key or symbol set."       )



def lowerCamelCase__						(       A_       ,			A_       ):
 return translate_message(A_       ,			A_       ,			"encrypt"       )



def lowerCamelCase__						(       A_       ,			A_       ):
 return translate_message(A_       ,			A_       ,			"decrypt"       )



def lowerCamelCase__						(       A_       ,			A_       ,			A_       ):
 UpperCAmelCase_				       =					""
 UpperCAmelCase_				       =					LETTERS
 UpperCAmelCase_				       =					key

 if mode == "decrypt":
  UpperCAmelCase_       ,       UpperCAmelCase_				       =					chars_b, chars_a

 for symbol in message:
  if symbol.upper() in chars_a:
   UpperCAmelCase_				       =					chars_a.find(symbol.upper()       )
   if symbol.isupper():
    translated += chars_b[sym_index].upper()
   else:
    translated += chars_b[sym_index].lower()
  else:
   translated += symbol

 return translated



def lowerCamelCase__						(       ):
 UpperCAmelCase_				       =					list(A_       )
 random.shuffle(A_       )
 return "".join(A_       )


if __name__ == "__main__":
      main()
