






class        a__      :





		class        a__      :
				UpperCAmelCase_							:       Dict 					= '_prev', '_data', '_next'






				def __init__(      self							, lowercase__							, lowercase__							, lowercase__						)				->				List[Any]:
						__A    =							link_p
						__A    =							element
						__A    =							link_n






				def 					_lowerCamelCase					(      self						)				->				Optional[Any]:
						return (
						    F""" Prev -> {self._prev is not None}, Next -> {self._next is not None}"""
						)






		def __init__(      self						)				->				Union[str, Any]:
				__A    =							self._Node(lowercase__							, lowercase__							, lowercase__						)
				__A    =							self._Node(lowercase__							, lowercase__							, lowercase__						)
				__A    =							self._trailer
				__A    =							self._header
				__A    =							0






		def __len__(      self						)				->				Tuple:
				return self._size






		def 					_lowerCamelCase					(      self						)				->				List[str]:
				return self.__len__() == 0






		def 					_lowerCamelCase					(      self							, lowercase__							, lowercase__							, lowercase__						)				->				str:
				# Create new_node by setting it's prev.link -> header
				# setting it's next.link -> trailer
				__A    =							self._Node(lowercase__							, lowercase__							, lowercase__						)
				__A    =							new_node
				__A    =							new_node
				self._size += 1
				return self






		def 					_lowerCamelCase					(      self							, lowercase__						)				->				Tuple:
				__A    =							node._prev
				__A    =							node._next

				__A    =							successor
				__A    =							predecessor
				self._size -= 1
				__A    =							node._data
				__A    =							__A    =							__A    =							None
				del node
				return temp





class        a__      (	_DoublyLinkedBase		):






		def 					_lowerCamelCase					(      self						)				->				int:
				if self.is_empty():
						raise Exception("List is empty"						)
				return self._header._next._data






		def 					_lowerCamelCase					(      self						)				->				Optional[int]:
				if self.is_empty():
						raise Exception("List is empty"						)
				return self._trailer._prev._data






		def 					_lowerCamelCase					(      self							, lowercase__						)				->				List[str]:
				return self._insert(self._header							, lowercase__							, self._header._next						)






		def 					_lowerCamelCase					(      self							, lowercase__						)				->				int:
				return self._insert(self._trailer._prev							, lowercase__							, self._trailer						)






		def 					_lowerCamelCase					(      self						)				->				Tuple:
				if self.is_empty():
						raise IndexError("remove_first from empty list"						)
				return self._delete(self._header._next						)






		def 					_lowerCamelCase					(      self						)				->				List[str]:
				if self.is_empty():
						raise IndexError("remove_first from empty list"						)
				return self._delete(self._trailer._prev						)


"""simple docstring"""
from __future__ import annotations

import sys







def 		__a  (      _SCREAMING_SNAKE_CASE  )      ->int:
  if n < 0:
    raise ValueError('Negative arguments are not supported'  )
  return _fib(_SCREAMING_SNAKE_CASE  )[0]







def 		__a  (      _SCREAMING_SNAKE_CASE  )      ->tuple[int, int]:
  if n == 0:  # (F(0), F(1))
    return (0, 1)

  # F(2n) = F(n)[2F(n+1) − F(n)]
  # F(2n+1) = F(n+1)^2+F(n)^2
  a__				,       a__:	Optional[int]     				=      _fib(n // 2  )
  a__:	List[str]     				=      a * (b * 2 - a)
  a__:	Dict     				=      a * a + b * b
  return (d, c + d) if n % 2 else (c, d)


if __name__ == "__main__":
 lowercase__   			=      int(sys.argv[1])
 print(f"fibonacci({n}) is {fibonacci(n)}")


