




'''simple docstring'''





import random
import sys

a		:	str       =      'ABCDEFGHIJKLMNOPQRSTUVWXYZ'





def UpperCAmelCase    (       ):
    _a				:							Any							       =      input("""Enter message: """						)
    _a				:							List[str]							       =      'LFWOAYUISVKMNXPBDCRJTQEGHZ'
    _a				:							Tuple							       =      input("""Encrypt/Decrypt [e/d]: """						)

    check_valid_key(UpperCAmelCase_						)

    if resp.lower().startswith("""e"""						):
        _a				:							int							       =      'encrypt'
        _a				:							Optional[int]							       =      encrypt_message(UpperCAmelCase_   ,	UpperCAmelCase_						)
    elif resp.lower().startswith("""d"""						):
        _a				:							str							       =      'decrypt'
        _a				:							Dict							       =      decrypt_message(UpperCAmelCase_   ,	UpperCAmelCase_						)

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





def UpperCAmelCase    (       UpperCAmelCase_						):
    _a				:							List[Any]							       =      list(UpperCAmelCase_						)
    _a				:							Union[str, Any]							       =      list(UpperCAmelCase_						)
    key_list.sort()
    letters_list.sort()

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





def UpperCAmelCase    (       UpperCAmelCase_   ,	UpperCAmelCase_						):
    return translate_message(UpperCAmelCase_   ,	UpperCAmelCase_   ,	"""encrypt"""						)





def UpperCAmelCase    (       UpperCAmelCase_   ,	UpperCAmelCase_						):
    return translate_message(UpperCAmelCase_   ,	UpperCAmelCase_   ,	"""decrypt"""						)





def UpperCAmelCase    (       UpperCAmelCase_   ,	UpperCAmelCase_   ,	UpperCAmelCase_						):
    _a				:							Optional[int]							       =      ''
    _a				:							Any							       =      LETTERS
    _a				:							Tuple							       =      key

    if mode == "decrypt":
        _a				:							Tuple							       =      chars_b, chars_a

    for symbol in message:
        if symbol.upper() in chars_a:
            _a				:							int							       =      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 UpperCAmelCase    (       ):
    _a				:							Union[str, Any]							       =      list(UpperCAmelCase_						)
    random.shuffle(UpperCAmelCase_						)
    return "".join(UpperCAmelCase_						)


if __name__ == "__main__":
  main()








from __future__ import annotations

class   UpperCAmelCase    :






   def __init__(						self :							List[Any]    ,       UpperCamelCase_ :							int  )->      None:
     _lowercase:			Optional[Any]      =     data
     _lowercase:			Optional[int]      =     None

class   UpperCAmelCase    :






   def __init__(						self :							Optional[Any]  )->      Union[str, Any]:
     _lowercase:			List[str]      =     None






   def 			_a    (						self :							List[Any]    ,       UpperCamelCase_ :							int  )->      int:
     _lowercase:			Any      =     Node(UpperCamelCase_  )
     _lowercase:			List[Any]      =     self.head
     _lowercase:			List[str]      =     new_node
     return self.head.data






   def 			_a    (						self :							Tuple  )->      int | None:
     _lowercase:			List[str]      =     self.head
     _lowercase:			str      =     self.head
     if self.head:
       while fast_pointer and fast_pointer.next:
         _lowercase:			Optional[int]      =     fast_pointer.next.next
         _lowercase:			Tuple      =     slow_pointer.next
       return slow_pointer.data
     else:
       print('No element found.'  )
       return None


if __name__ == "__main__":
   UpperCAmelCase__    :							Union[str, Any]       		=     LinkedList()
   for _ in range(int(input().strip())):
      UpperCAmelCase__    :							List[Any]       		=     int(input().strip())
      link.push(data)
   print(link.middle_element())
