





from __future__ import annotations

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




class 			_lowerCamelCase	(      a      ):



      """simple docstring"""






      UpperCAmelCase_  : List[Any]				      =1
      UpperCAmelCase_  : List[Any]				      =2
      UpperCAmelCase_  : Optional[Any]				      =3







      def __repr__(	self				)    ->				Union[str, Any]:






        '''simple docstring'''






        return F"""{self.__class__.__name__}.{self.name}"""







def  lowerCAmelCase__(		lowercase    :      tuple[int, int]				,       lowercase    :      int				,       lowercase    :      int			)	->      float:
  __snake_case      ,				__snake_case				:			Union[str, Any]            =    point
  return degrees(atana(y - miny				,       x - minx			)			)







def  lowerCAmelCase__(		lowercase    :      tuple[int, int]				,       lowercase    :      tuple[int, int]				,       lowercase    :      tuple[int, int]			)	->      Direction:
  __snake_case      ,				__snake_case				:			Union[str, Any]            =    starting
  __snake_case      ,				__snake_case				:			int            =    via
  __snake_case      ,				__snake_case				:			Optional[Any]            =    target
  __snake_case				:			List[str]            =    degrees(atana(ya - ya				,       xa - xa			)			)
  via_angle %= 360
  __snake_case				:			List[str]            =    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  lowerCAmelCase__(		lowercase    :      list[tuple[int, int]]			)	->      list[tuple[int, int]]:

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

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

  __snake_case				:			Optional[int]            =    sorted(lowercase				,       key=lambda lowercase			: angle_comparer(lowercase				,       lowercase				,       lowercase			)			)
  # 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)			)

  __snake_case				:			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.
  __snake_case				:			Union[str, Any]            =    Direction.left

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

      if next_direction == Direction.left:
        __snake_case				:			str            =    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(lowercase			)








def  lowerCAmelCase__(		lowercase    :      int = 10**6			)	->      int:

  if n <= 0:
    raise ValueError("Please enter an integer greater than 0"			)

  __snake_case				:			List[Any]            =    list(range(n + 1			)			)
  for number in range(2				,       n + 1			):
    if phi[number] == number:
      phi[number] -= 1
      for multiple in range(number * 2				,       n + 1				,       lowercase			):
        __snake_case				:			Optional[int]            =    (phi[multiple] // number) * (number - 1)

  __snake_case				:			List[Any]            =    1
  for number in range(1				,       n + 1			):
    if (answer / phi[answer]) < (number / phi[number]):
      __snake_case				:			List[str]            =    number

  return answer


if __name__ == "__main__":
     print(solution())

