code: 
  from __future__ import annotations
  
  
  
  
  
  class      UpperCamelCase_			:
  
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						def __init__( self       :Tuple		,						lowerCAmelCase__       :int    )     ->None:
  										lowercase						    =			data
  										lowercase						    =			None
  
  
  
  
  
  class      UpperCamelCase_			:
  
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						def __init__( self       :Dict    )     ->Union[str, Any]:
  										lowercase						    =			None
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :List[str]		,						lowerCAmelCase__       :int    )     ->int:
  										lowercase						    =			Node(lowerCAmelCase__    )
  										lowercase						    =			self.head
  										lowercase						    =			new_node
  										return self.head.data
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Any    )     ->int | None:
  										lowercase						    =			self.head
  										lowercase						    =			self.head
  										if self.head:
  														while fast_pointer and fast_pointer.next:
  																		lowercase						    =			fast_pointer.next.next
  																		lowercase						    =			slow_pointer.next
  														return slow_pointer.data
  										else:
  														print("No element found."    )
  														return None
  
  
  if __name__ == "__main__":
  						_snake_case			:       str      =						LinkedList()
  						for _ in range(int(input().strip())):
  												_snake_case			:       Optional[Any]      =						int(input().strip())
  												link.push(data)
  						print(link.middle_element())
  
style_context: 
  from __future__ import annotations
  
  import random
  import string
  
  
  
  
  
  class      UpperCamelCase_			:
  
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						def __init__( self       :Dict		,						lowerCAmelCase__       :str | None = None    )     ->None:
  										lowercase						    =			passcode or self.__passcode_creator()
  										lowercase						    =			self.__make_key_list()
  										lowercase						    =			self.__make_shift_key()
  
  
  
  
  
  						def __str__( self       :Dict    )     ->str:
  										return "".join(self.__passcode    )
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :str		,						lowerCAmelCase__       :list[int]    )     ->list[int]:
  										for i in range(1		,						len(lowerCAmelCase__    )		,						2    ):
  														iterlist[i] *= -1
  										return iterlist
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :int    )     ->list[str]:
  										lowercase						    =			string.ascii_letters + string.digits
  										lowercase						    =			[random.choice(lowerCAmelCase__    ) for _ in range(random.randint(10		,						20    )    )]
  										return password
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Union[str, Any]    )     ->list[str]:
  										lowercase						    =			(
  										    string.ascii_letters + string.digits + string.punctuation + " \t\n"
  										)
  
  										lowercase						    =			[]
  
  										# creates points known as breakpoints to break the key_list_options at those
  										# points and pivot each substring
  										lowercase						    =			sorted(set(self.__passcode    )    )
  										lowercase						    =			[]
  
  										# algorithm for creating a new shuffled list, keys_l, out of key_list_options
  										for i in key_list_options:
  														temp_list.extend(lowerCAmelCase__    )
  
  														# 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 					SCREAMING_SNAKE_CASE( self       :Optional[int]    )     ->int:
  										lowercase						    =			sum(self.__neg_pos([ord(lowerCAmelCase__    ) for x in self.__passcode]    )    )
  										return num if num > 0 else len(self.__passcode    )
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :str		,						lowerCAmelCase__       :str    )     ->str:
  										lowercase						    =			""
  
  										# decoding shift like Caesar cipher algorithm implementing negative shift or
  										# reverse shift or left shift
  										for i in encoded_message:
  														lowercase						    =			self.__key_list.index(lowerCAmelCase__    )
  														decoded_message += self.__key_list[
  														    (position - self.__shift_key) % -len(self.__key_list    )
  														]
  
  										return decoded_message
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Dict		,						lowerCAmelCase__       :str    )     ->str:
  										lowercase						    =			""
  
  										# encoding shift like Caesar cipher algorithm implementing positive shift or
  										# forward shift or right shift
  										for i in plaintext:
  														lowercase						    =			self.__key_list.index(lowerCAmelCase__    )
  														encoded_message += self.__key_list[
  														    (position + self.__shift_key) % len(self.__key_list    )
  														]
  
  										return encoded_message
  
  
  
  
  def    __snake_case       (  __magic_name__ = "Hello, this is a modified Caesar cipher"	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			ShuffledShiftCipher()
  				return cipa.decrypt(cipa.encrypt(__magic_name__	)	)
  
  
  if __name__ == "__main__":
  						import doctest
  
  						doctest.testmod()
  