



"""simple docstring"""




def 						__snake_case						(      SCREAMING_SNAKE_CASE__	:						List[str]				)  ->   Tuple:





     '''simple docstring'''

     if not isinstance(SCREAMING_SNAKE_CASE__						,  SCREAMING_SNAKE_CASE__				):
          _UpperCAmelCase			:	Dict								=    (
              'operation can not be conducted on a object of type '
              f'{type(SCREAMING_SNAKE_CASE__				).__name__}'
          )
          raise TypeError(SCREAMING_SNAKE_CASE__				)
     _UpperCAmelCase			:	Optional[int]								=    ''
     for _ in range(0						,  32				):
          bit_string += str(number % 2				)
          _UpperCAmelCase			:	Tuple								=    number >> 1
     return bit_string

def 						__snake_case						(      SCREAMING_SNAKE_CASE__	:						List[str]				)  ->   List[Any]:





     '''simple docstring'''

     if number < 0:
          raise ValueError("the value of input must be positive"				)
     elif isinstance(SCREAMING_SNAKE_CASE__						,  SCREAMING_SNAKE_CASE__				):
          raise TypeError("Input value must be a \'int\' type"				)
     elif isinstance(SCREAMING_SNAKE_CASE__						,  SCREAMING_SNAKE_CASE__				):
          raise TypeError("\'<\' not supported between instances of \'str\' and \'int\'"				)
     _UpperCAmelCase			:	Optional[int]								=    0
     # iterator over [1 to 32],since we are dealing with 32 bit integer
     for _ in range(1						,  33				):
          # left shift the bits by unity
          _UpperCAmelCase			:	List[Any]								=    result << 1
          # get the end bit
          _UpperCAmelCase			:	List[Any]								=    number % 2
          # right shift the bits by unity
          _UpperCAmelCase			:	List[str]								=    number >> 1
          # add that bit to our ans
          _UpperCAmelCase			:	List[Any]								=    result | end_bit
     return get_reverse_bit_string(SCREAMING_SNAKE_CASE__				)


if __name__ == "__main__":
 import doctest

 doctest.testmod()




from __future__ import annotations


class        A_					:




      '''simple docstring'''


      def __init__(				self:       Union[str, Any]						,      a:       int				):
       __lowerCamelCase		:							List[Any]							=						data
       __lowerCamelCase		:							Optional[Any]							=						None



class        A_					:




      '''simple docstring'''


      def __init__(				self:       Dict				):
       __lowerCamelCase		:							Dict							=						None




      def      _snake_case	(				self:       Dict						,      a:       int				):
       __lowerCamelCase		:							List[Any]							=						Node(a				)
       __lowerCamelCase		:							Dict							=						self.head
       __lowerCamelCase		:							Optional[int]							=						new_node
       return self.head.data




      def      _snake_case	(				self:       Optional[Any]				):
       __lowerCamelCase		:							Union[str, Any]							=						self.head
       __lowerCamelCase		:							List[Any]							=						self.head
       if self.head:
        while fast_pointer and fast_pointer.next:
         __lowerCamelCase		:							Any							=						fast_pointer.next.next
         __lowerCamelCase		:							str							=						slow_pointer.next
        return slow_pointer.data
       else:
        print('No element found.'				)
        return None


if __name__ == "__main__":
       lowercase_           =	LinkedList()
       for _ in range(int(input().strip())):
              lowercase_           =	int(input().strip())
              link.push(data)
       print(link.middle_element())

