


lowercase_           =	[0.33, 0.44, 0.55, 0.44, 0.33]
lowercase_           =	3
lowercase_           =	5

# Buffer Space (with Parameters Space)
lowercase_           =	[]
lowercase_           =	[]

# Machine Time
lowercase_           =	0
def       UpperCamelCase__     (  SCREAMING_SNAKE_CASE__						):
 global buffer_space, params_space, machine_time, K, m, t

 # Choosing Dynamical Systems (All)
 for key, value in enumerate(SCREAMING_SNAKE_CASE__						):
  # Evolution Parameter
  __lowerCamelCase		:							Dict							=						float(seed / value						)

  # Control Theory: Orbit Change
  __lowerCamelCase		:							int							=						(buffer_space[(key + 1) % m] + e) % 1

  # Control Theory: Trajectory Change
  __lowerCamelCase		:							Optional[int]							=						(params_space[key] + e) % 1 + 3

  # Modification (Transition Function) - Jumps
  __lowerCamelCase		:							Any							=						round(float(r * value * (1 - value)						)			,       10						)
  __lowerCamelCase		:							Tuple							=						r  # Saving to Parameters Space

 # Logistic Map
 assert max(SCREAMING_SNAKE_CASE__						) < 1
 assert max(SCREAMING_SNAKE_CASE__						) < 4

 # Machine Time
 machine_time += 1
def       UpperCamelCase__     (  ):
 global buffer_space, params_space, machine_time, K, m, t

 # PRNG (Xorshift by George Marsaglia)
 def xorshift(SCREAMING_SNAKE_CASE__			,       SCREAMING_SNAKE_CASE__						):
  x ^= y >> 13
  y ^= x << 17
  x ^= y >> 5
  return x

 # Choosing Dynamical Systems (Increment)
 __lowerCamelCase		:							Optional[Any]							=						machine_time % m

 # Evolution (Time Length)
 for _ in range(0			,       SCREAMING_SNAKE_CASE__						):
  # Variables (Position + Parameters)
  __lowerCamelCase		:							str							=						params_space[key]
  __lowerCamelCase		:							Dict							=						buffer_space[key]

  # Modification (Transition Function) - Flow
  __lowerCamelCase		:							List[str]							=						round(float(r * value * (1 - value)						)			,       10						)
  __lowerCamelCase		:							Tuple							=						(machine_time * 0.01 + r * 1.01) % 1 + 3

 # Choosing Chaotic Data
 __lowerCamelCase		:							Tuple							=						int(buffer_space[(key + 2) % m] * (10**10)						)
 __lowerCamelCase		:							Tuple							=						int(buffer_space[(key - 2) % m] * (10**10)						)

 # Machine Time
 machine_time += 1

 return xorshift(SCREAMING_SNAKE_CASE__			,       SCREAMING_SNAKE_CASE__						) % 0Xffff_ffff
def       UpperCamelCase__     (  ):
 global buffer_space, params_space, machine_time, K, m, t

 __lowerCamelCase		:							str							=						K
 __lowerCamelCase		:							Union[str, Any]							=						[0] * m
 __lowerCamelCase		:							Any							=						0


if __name__ == "__main__":
       # Initialization
       reset()

       # Pushing Data (Input)
       import random

       lowercase_           =	random.sample(range(0xF_F_F_F_F_F_F_F), 1_0_0)
       for chunk in message:
              push(chunk)

       # for controlling
       lowercase_           =	''

       # Pulling Data (Output)
       while inp in ("e", "E"):
              print(F"""{format(pull(), '#04x')}""")
              print(buffer_space)
              print(params_space)
              lowercase_           =	input('(e)exit? ').strip()





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())

