code: 
  
  
  '''simple docstring'''
  
  
  
  
  from math import cos, sin
  
  
  
  
  
  def 							a_       (						lowercase    )			->list[list[float]]:
  
  
  
  
  
  
  				'''simple docstring'''
  
  				__lowerCamelCase		:      int											=					float(lowercase    )
  				return [[scaling_factor * int(x == y    ) for x in range(2    )] for y in range(2    )]
  
  
  
  
  
  def 							a_       (						lowercase    )			->list[list[float]]:
  
  
  
  
  
  
  				'''simple docstring'''
  
  				__lowerCamelCase						,					__lowerCamelCase		:      Tuple											=					cos(lowercase    ), sin(lowercase    )
  				return [[c, -s], [s, c]]
  
  
  
  
  
  def 							a_       (						lowercase    )			->list[list[float]]:
  
  
  
  
  
  
  				'''simple docstring'''
  
  				__lowerCamelCase						,					__lowerCamelCase		:      Union[str, Any]											=					cos(lowercase    ), sin(lowercase    )
  				__lowerCamelCase		:      Optional[int]											=					c * s
  				return [[c * c, cs], [cs, s * s]]
  
  
  
  
  
  def 							a_       (						lowercase    )			->list[list[float]]:
  
  
  
  
  
  
  				'''simple docstring'''
  
  				__lowerCamelCase						,					__lowerCamelCase		:      Optional[Any]											=					cos(lowercase    ), sin(lowercase    )
  				__lowerCamelCase		:      Dict											=					c * s
  				return [[2 * c - 1, 2 * cs], [2 * cs, 2 * s - 1]]
  
  
  print(f"    {scaling(5) = }")
  print(f"  {rotation(45) = }")
  print(f"{projection(45) = }")
  
  
  
  print(f"{reflection(45) = }")
  
  
  
  
  
  
style_context: 
  
  
  '''simple docstring'''
  
  
  
  
  from __future__ import annotations
  
  from collections import deque
  from enum import Enum
  from math import atana, degrees
  from sys import maxsize
  
  
  
  
  
  class _snake_case   ( a__   ):
  							"""simple docstring"""
  
  
  
  
  
  							__a												=     1
  							__a												=     2
  							__a												=     3
  
  
  
  
  
  
  
  							def __repr__(   self	)     ->Tuple:
  
  
  
  											"""simple docstring"""
  
  
  
  
  
  
  
  											return f'{self.__class__.__name__}.{self.name}'
  
  
  
  
  
  def 							a_       (						lowercase							,						lowercase							,						lowercase    )			->float:
  
  
  
  
  
  
  				'''simple docstring'''
  
  				__lowerCamelCase						,					__lowerCamelCase		:      str											=					point
  				return degrees(atana(y - miny							,						x - minx    )    )
  
  
  
  
  
  def 							a_       (						lowercase							,						lowercase							,						lowercase    )			->Direction:
  
  
  
  
  
  
  				'''simple docstring'''
  
  				__lowerCamelCase						,					__lowerCamelCase		:      List[str]											=					starting
  				__lowerCamelCase						,					__lowerCamelCase		:      Any											=					via
  				__lowerCamelCase						,					__lowerCamelCase		:      str											=					target
  				__lowerCamelCase		:      str											=					degrees(atana(ya - ya							,						xa - xa    )    )
  				via_angle %= 360
  				__lowerCamelCase		:      List[Any]											=					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 							a_       (						lowercase    )			->list[tuple[int, int]]:
  
  
  
  
  
  
  				'''simple docstring'''
  
  				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
  				__lowerCamelCase		:      Optional[Any]											=					0
  				__lowerCamelCase						,					__lowerCamelCase		:      List[Any]											=					maxsize, maxsize
  				for i, point in enumerate(lowercase    ):
  								__lowerCamelCase		:      Dict											=					point[0]
  								__lowerCamelCase		:      Optional[int]											=					point[1]
  								if y < miny:
  												__lowerCamelCase		:      Dict											=					y
  												__lowerCamelCase		:      int											=					x
  												__lowerCamelCase		:      List[Any]											=					i
  								if y == miny and x < minx:
  												__lowerCamelCase		:      Optional[int]											=					x
  												__lowerCamelCase		:      Any											=					i
  
      # remove the lowest and the most left point from points for preparing for sort
  				points.pop(lowercase    )
  
  				__lowerCamelCase		:      Optional[Any]											=					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)    )
  
  				__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		:      str											=					Direction.left
  
  				for i in range(3							,						len(lowercase    )    ):
  								while True:
  												__lowerCamelCase		:      List[Any]											=					stack[-2]
  												__lowerCamelCase		:      str											=					stack[-1]
  												__lowerCamelCase		:      int											=					sorted_points[i]
  												__lowerCamelCase		:      List[Any]											=					check_direction(lowercase							,						lowercase							,						lowercase    )
  
  												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(lowercase    )
  
  
  
  
  
  