


"""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_  ( a_						):
      __magic_name__     :							List[str]          =				1
      __magic_name__     :							str          =				2
      __magic_name__     :							Optional[Any]          =				3







      def __repr__(      self :							Optional[int]    ):
        return f"{self.__class__.__name__}.{self.name}"





def     lowercase__	(  lowerCamelCase     :  tuple[int, int]				,	lowerCamelCase     :  int				,	lowerCamelCase     :  int				)					->     float:
  lowerCAmelCase__				,		lowerCAmelCase__    :    Dict								=					point
  return degrees(atana(y - miny				,	x - minx				)				)





def     lowercase__	(  lowerCamelCase     :  tuple[int, int]				,	lowerCamelCase     :  tuple[int, int]				,	lowerCamelCase     :  tuple[int, int]				)					->     Direction:
  lowerCAmelCase__				,		lowerCAmelCase__    :    Union[str, Any]								=					starting
  lowerCAmelCase__				,		lowerCAmelCase__    :    List[Any]								=					via
  lowerCAmelCase__				,		lowerCAmelCase__    :    Any								=					target
  lowerCAmelCase__    :    Union[str, Any]								=					degrees(atana(ya - ya				,	xa - xa				)				)
  via_angle %= 3_6_0
  lowerCAmelCase__    :    int								=					degrees(atana(ya - ya				,	xa - xa				)				)
  target_angle %= 3_6_0
  # 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     lowercase__	(  lowerCamelCase     :  list[tuple[int, int]]				)					->     list[tuple[int, int]]:

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

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

  lowerCAmelCase__    :    Dict								=					sorted(lowerCamelCase				,	key=lambda lowerCamelCase				: angle_comparer(lowerCamelCase				,	lowerCamelCase				,	lowerCamelCase				)				)
  # 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__    :    Optional[Any]								=					Direction.left

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

      if next_direction == Direction.left:
        lowerCAmelCase__    :    List[Any]								=					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(lowerCamelCase				)




"""simple docstring"""





def     lowercase__	(  lowerCamelCase     :  int				)					->     int:
  if not isinstance(lowerCamelCase				,	lowerCamelCase				):
    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     lowercase__	(  lowerCamelCase     :  int				)					->     int:
  if not isinstance(lowerCamelCase				,	lowerCamelCase				):
    raise TypeError("dynamic_lucas_number accepts only integer arguments."				)
  lowerCAmelCase__				,		lowerCAmelCase__    :    str								=					2, 1
  for _ in range(lowerCamelCase				):
    lowerCAmelCase__				,		lowerCAmelCase__    :    str								=					b, a + b
  return a


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

   testmod()
   __UpperCAmelCase    				=      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)))
