




"""simple docstring"""

from __future__ import annotations

class 							lowercase   :







				def __init__(				self :       List[str]   ,  _lowerCamelCase :       int							):



					"""simple docstring"""

					A_	:					str						 =		data
					A_	:					List[str]						 =		None

class 							lowercase   :







				def __init__(				self :       int							):



					"""simple docstring"""

					A_	:					List[Any]						 =		None







				def        a_	(				self :       List[Any]   ,  _lowerCamelCase :       int							):



					"""simple docstring"""

					A_	:					Dict						 =		Node(_lowerCamelCase							)
					A_	:					List[Any]						 =		self.head
					A_	:					Optional[int]						 =		new_node
					return self.head.data







				def        a_	(				self :       Optional[int]							):



					"""simple docstring"""

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


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











"""simple docstring"""

from __future__ import annotations

def 		lowercase_   (		_UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase						):




	"""simple docstring"""






	assert (
	    c % greatest_common_divisor(_UpperCAmelCase	,   _UpperCAmelCase						) == 0
	)  # greatest_common_divisor(a,b) function implemented below
	((A_) ,			(A_) ,			(A_))	:					List[Any]						 =		extended_gcd(_UpperCAmelCase	,   _UpperCAmelCase						)  # extended_gcd(a,b) function implemented below
	A_	:					int						 =		c / d
	return (r * x, r * y)

def 		lowercase_   (		_UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase = 2						):




	"""simple docstring"""






	((A_) ,			(A_))	:					Any						 =		diophantine(_UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase						)  # Initial value
	A_	:					Union[str, Any]						 =		greatest_common_divisor(_UpperCAmelCase	,   _UpperCAmelCase						)
	A_	:					List[str]						 =		a // d
	A_	:					str						 =		b // d

	for i in range(_UpperCAmelCase						):
		A_	:					int						 =		xa + i * q
		A_	:					str						 =		ya - i * p
		print(_UpperCAmelCase	,   _UpperCAmelCase						)

def 		lowercase_   (		_UpperCAmelCase	,   _UpperCAmelCase						):




	"""simple docstring"""






	if a < b:
		A_ ,			A_	:					Tuple						 =		b, a

	while a % b != 0:
		A_ ,			A_	:					int						 =		b, a % b

	return b

def 		lowercase_   (		_UpperCAmelCase	,   _UpperCAmelCase						):




	"""simple docstring"""






	assert a >= 0 and b >= 0

	if b == 0:
		A_ ,			A_ ,			A_	:					str						 =		a, 1, 0
	else:
		((A_) ,			(A_) ,			(A_))	:					List[str]						 =		extended_gcd(_UpperCAmelCase	,   a % b						)
		A_	:					Optional[int]						 =		q
		A_	:					Tuple						 =		p - q * (a // b)

	assert a % d == 0 and b % d == 0
	assert d == a * x + b * y

	return (d, x, y)


if __name__ == "__main__":
		from doctest import testmod

		testmod(name='diophantine', verbose=True)
		testmod(name='diophantine_all_soln', verbose=True)
		testmod(name='extended_gcd', verbose=True)
		testmod(name='greatest_common_divisor', verbose=True)





