from __future__ import annotations

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





class 	_lowercase		(      snake_case_ ):
 lowercase         =     1
 lowercase         =     2
 lowercase         =     3

 def __repr__(				self			:							int    )     ->		Any:

  """simple docstring"""





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





def      __lowercase  (		lowerCamelCase      :  tuple[int, int]						,						lowerCamelCase      :  int						,						lowerCamelCase      :  int			):
 UpperCamelCase_      :		str				=      point
 return degrees(atana(y - miny						,						x - minx			)			)





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

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

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

 UpperCamelCase_      :		str				=      sorted(UpperCamelCase__						,						key=lambda lowerCamelCase			: angle_comparer(UpperCamelCase__						,						UpperCamelCase__						,						UpperCamelCase__			)			)
 # 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)			)

 UpperCamelCase_      :		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.
 UpperCamelCase_      :		List[Any]				=      Direction.left

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

   if next_direction == Direction.left:
    UpperCamelCase_      :		Union[str, 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(UpperCamelCase__			)




def      __lowercase  (		lowerCamelCase      :  int = 998001			):
 UpperCamelCase_      :		int				=      0
 for i in range(999						,						99						,						-1			):  # 3 digit numbers range from 999 down to 100
  for j in range(999						,						99						,						-1			):
   UpperCamelCase_      :		str				=      str(i * j			)
   if product_string == product_string[::-1] and i * j < n:
    UpperCamelCase_      :		str				=      max(lowerCamelCase						,						i * j			)
 return answer


if __name__ == "__main__":
   print(F"""{solution() = }""")



