
"""simple docstring"""

from __future__ import annotations

from collections import deque
from enum import Enum
from math import atana, degrees
from sys import maxsize






class 			_lowercase  (							__UpperCAmelCase						):
	lowercase_								=      1
	lowercase_								=      2
	lowercase_								=      3




	def __repr__(					self   )						->				Union[str, Any]:
			return F"""{self.__class__.__name__}.{self.name}"""


def 						UpperCAmelCase   (						a_,		a_,		a_     ):





		'''simple docstring'''


		lowerCamelCase      ,       lowerCamelCase	:     Tuple            =       point
		return degrees(atana(y - miny,		x - minx     )     )
def 						UpperCAmelCase   (						a_,		a_,		a_     ):





		'''simple docstring'''


		lowerCamelCase      ,       lowerCamelCase	:     int            =       starting
		lowerCamelCase      ,       lowerCamelCase	:     str            =       via
		lowerCamelCase      ,       lowerCamelCase	:     Dict            =       target
		lowerCamelCase	:     Optional[Any]            =       degrees(atana(ya - ya,		xa - xa     )     )
		via_angle %= 360
		lowerCamelCase	:     int            =       degrees(atana(ya - ya,		xa - xa     )     )
		target_angle %= 360
		# t-
		#  \ \
		#   \ v
		#    \|
		#     s
		# via_angle is always lower than target_angle, if direction is left.
		# If they are same, it means they are on a same line of convex hull.
		if target_angle > via_angle:
				return Direction.left
		elif target_angle == via_angle:
				return Direction.straight
		else:
				return Direction.right





def 						UpperCAmelCase   (						a_     ):





		'''simple docstring'''


		if len(a_     ) <= 2:
				# There is no convex hull
				raise ValueError('graham_scan: argument must contain more than 3 points.'     )
		if len(a_     ) == 3:
				return points
		# find the lowest and the most left point
		lowerCamelCase	:     Optional[Any]            =       0
		lowerCamelCase      ,       lowerCamelCase	:     Union[str, Any]            =       maxsize, maxsize
		for i, point in enumerate(a_     ):
				lowerCamelCase	:     Union[str, Any]            =       point[0]
				lowerCamelCase	:     Optional[Any]            =       point[1]
				if y < miny:
						lowerCamelCase	:     Union[str, Any]            =       y
						lowerCamelCase	:     Union[str, Any]            =       x
						lowerCamelCase	:     Dict            =       i
				if y == miny and x < minx:
						lowerCamelCase	:     Optional[int]            =       x
						lowerCamelCase	:     Optional[int]            =       i

    # remove the lowest and the most left point from points for preparing for sort
		points.pop(a_     )

		lowerCamelCase	:     Optional[int]            =       sorted(a_,		key=lambda a_     : angle_comparer(a_,		a_,		a_     )     )
		# This insert actually costs complexity,
		# and you should instead add (minx, miny) into stack later.
		# I'm using insert just for easy understanding.
		sorted_points.insert(0,		(minx, miny)     )

		lowerCamelCase	:     deque[tuple[int, int]]            =       deque()
		stack.append(sorted_points[0]     )
		stack.append(sorted_points[1]     )
		stack.append(sorted_points[2]     )
		# In any ways, the first 3 points line are towards left.
		# Because we sort them the angle from minx, miny.
		lowerCamelCase	:     Dict            =       Direction.left

		for i in range(3,		len(a_     )     ):
				while True:
						lowerCamelCase	:     List[Any]            =       stack[-2]
						lowerCamelCase	:     List[str]            =       stack[-1]
						lowerCamelCase	:     List[Any]            =       sorted_points[i]
						lowerCamelCase	:     Optional[int]            =       check_direction(a_,		a_,		a_     )

						if next_direction == Direction.left:
								lowerCamelCase	:     Optional[int]            =       Direction.left
								break
						if next_direction == Direction.straight:
								if current_direction == Direction.left:
										# We keep current_direction as left.
										# Because if the straight line keeps as straight,
										# we want to know if this straight line is towards left.
										break
								elif current_direction == Direction.right:
										# If the straight line is towards right,
										# every previous points on those straigh line is not convex hull.
										stack.pop()
						if next_direction == Direction.right:
								stack.pop()
				stack.append(sorted_points[i]     )
		return list(a_     )








"""simple docstring"""

def 						UpperCAmelCase   (						a_     ):





		'''simple docstring'''


		if not isinstance(a_,		a_     ):
				raise TypeError('recursive_lucas_number accepts only integer arguments.'     )
		if n_th_number == 0:
				return 2
		if n_th_number == 1:
				return 1

		return recursive_lucas_number(n_th_number - 1     ) + recursive_lucas_number(
		    n_th_number - 2     )
def 						UpperCAmelCase   (						a_     ):





		'''simple docstring'''


		if not isinstance(a_,		a_     ):
				raise TypeError('dynamic_lucas_number accepts only integer arguments.'     )
		lowerCamelCase      ,       lowerCamelCase	:     Optional[int]            =       2, 1
		for _ in range(a_     ):
				lowerCamelCase      ,       lowerCamelCase	:     Optional[int]            =       b, a + b
		return a


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

					testmod()
					_A				=					int(input('Enter the number of terms in lucas series:\n').strip())
					print('Using recursive function to calculate lucas series:')
					print(' '.join(str(recursive_lucas_number(i)) for i in range(n)))
					print('\nUsing dynamic function to calculate lucas series:')
					print(' '.join(str(dynamic_lucas_number(i)) for i in range(n)))






