






'''simple docstring'''







from __future__ import annotations

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






class        a__     (      lowerCamelCase    ):
     '''simple docstring'''







     _snake_case							   =	1
     _snake_case							   =	2
     _snake_case							   =	3






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







def     _UpperCamelCase				(  snake_case__				,      snake_case__				,      snake_case__				):
      __A ,					__A		 =   point
      return degrees(atana(y - miny				,      x - minx				)				)


def     _UpperCamelCase				(  snake_case__				,      snake_case__				,      snake_case__				):
      __A ,					__A		 =   starting
      __A ,					__A		 =   via
      __A ,					__A		 =   target
      __A		 =   degrees(atana(ya - ya				,      xa - xa				)				)
      via_angle %= 360
      __A		 =   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				(  snake_case__				):

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

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

      __A		 =   sorted(snake_case__				,      key=lambda snake_case__				: angle_comparer(snake_case__				,      snake_case__				,      snake_case__				)				)
      # 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)				)

      __A		 =   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.
      __A		 =   Direction.left

      for i in range(3				,      len(snake_case__				)				):
            while True:
                  __A		 =   stack[-2]
                  __A		 =   stack[-1]
                  __A		 =   sorted_points[i]
                  __A		 =   check_direction(snake_case__				,      snake_case__				,      snake_case__				)

                  if next_direction == Direction.left:
                        __A		 =   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(snake_case__				)










'''simple docstring'''







def     _UpperCamelCase				(  snake_case__ = 1_000				):
      __A		 =   []
      __A		 =   []
      __A		 =   3
      __A		 =   5
      __A		 =   1
      while True:
            __A		 =   z * temp
            if result < n:
                  zmulti.append(snake_case__				)
                  temp += 1
            else:
                  __A		 =   1
                  break
      while True:
            __A		 =   x * temp
            if result < n:
                  xmulti.append(snake_case__				)
                  temp += 1
            else:
                  break
      __A		 =   list(set(xmulti + zmulti				)				)
      return sum(snake_case__				)


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


