




"""simple docstring"""

import math




def       snake_case__	(       lowerCAmelCase   :		Optional[Any]		):
					__snake_case          =	0
					if n % 2 == 0:
										count += 1
										while n % 2 == 0:
															__snake_case          =	int(n / 2		)
    # the n input value must be odd so that
    # we can skip one element (ie i += 2)

					__snake_case          =	3

					while i <= int(math.sqrt(lowerCAmelCase		)		):
										if n % i == 0:
															count += 1
															while n % i == 0:
																				__snake_case          =	int(n / i		)
										__snake_case          =	i + 2

					# this condition checks the prime
					# number n is greater than 2

					if n > 2:
										count += 1
					return count


if __name__ == "__main__":
		UpperCamelCase__ :    List[Any] 					=							51_24_21_83
		print(f'The number of distinct prime factors is/are {exact_prime_factor_count(n)}')
		print(f'The value of log(log(n)) is {math.log(math.log(n)):.4f}')








"""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__      (      lowercase_     ):
	A_							:				Tuple						     =      1
	A_							:				Union[str, Any]						     =      2
	A_							:				Union[str, Any]						     =      3




	def __repr__(   self  :	Dict	)					-> Union[str, Any]:
						return f'''{self.__class__.__name__}.{self.name}'''




def       snake_case__	(       lowerCAmelCase   :		tuple[int, int]				,					lowerCAmelCase   :		int				,					lowerCAmelCase   :		int		):
					__snake_case      ,      __snake_case          =	point
					return degrees(atana(y - miny				,					x - minx		)		)




def       snake_case__	(       lowerCAmelCase   :		tuple[int, int]				,					lowerCAmelCase   :		tuple[int, int]				,					lowerCAmelCase   :		tuple[int, int]		):
					__snake_case      ,      __snake_case          =	starting
					__snake_case      ,      __snake_case          =	via
					__snake_case      ,      __snake_case          =	target
					__snake_case          =	degrees(atana(ya - ya				,					xa - xa		)		)
					via_angle %= 360
					__snake_case          =	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       snake_case__	(       lowerCAmelCase   :		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
					__snake_case          =	0
					__snake_case      ,      __snake_case          =	maxsize, maxsize
					for i, point in enumerate(lowerCAmelCase		):
										__snake_case          =	point[0]
										__snake_case          =	point[1]
										if y < miny:
															__snake_case          =	y
															__snake_case          =	x
															__snake_case          =	i
										if y == miny and x < minx:
															__snake_case          =	x
															__snake_case          =	i

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

					__snake_case          =	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)		)

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

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

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


