





from __future__ import annotations

from fractions import Fraction
from math import gcd, sqrt


def  A							(			snake_case__   :						int				)					->				List[Any]:
 '''simple docstring'''
 __snake_case         =			int(number**0.5				)
 return number == sq * sq


def  A							(			snake_case__   :						int ,				snake_case__   :						int ,				snake_case__   :						int ,				snake_case__   :						int ,				snake_case__   :						int ,				snake_case__   :						int				)					->				str:
 '''simple docstring'''
 __snake_case         =			x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den
 __snake_case         =			x_den * y_den * z_den
 __snake_case         =			gcd(lowerCamelCase_ ,				lowerCamelCase_				)
 top //= hcf
 bottom //= hcf
 return top, bottom


def  A							(			snake_case__   :						int = 35				)					->				Optional[int]:
 '''simple docstring'''
 __snake_case         =			set()
 __snake_case         =			42
 __snake_case         =			Fraction(0				)
 __snake_case         =			42

 for x_num in range(1 ,				order + 1				):
  for x_den in range(x_num + 1 ,				order + 1				):
   for y_num in range(1 ,				order + 1				):
    for y_den in range(y_num + 1 ,				order + 1				):
     # n=1
     __snake_case         =			x_num * y_den + x_den * y_num
     __snake_case         =			x_den * y_den
     __snake_case         =			gcd(lowerCamelCase_ ,				lowerCamelCase_				)
     z_num //= hcf
     z_den //= hcf
     if 0 < z_num < z_den <= order:
      __snake_case         =			add_three(
          lowerCamelCase_ ,				lowerCamelCase_ ,				lowerCamelCase_ ,				lowerCamelCase_ ,				lowerCamelCase_ ,				lowerCamelCase_				)
      unique_s.add(lowerCamelCase_				)

     # n=2
     __snake_case         =			(
         x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num
     )
     __snake_case         =			x_den * x_den * y_den * y_den
     if is_sq(lowerCamelCase_				) and is_sq(lowerCamelCase_				):
      __snake_case         =			int(sqrt(lowerCamelCase_				)				)
      __snake_case         =			int(sqrt(lowerCamelCase_				)				)
      __snake_case         =			gcd(lowerCamelCase_ ,				lowerCamelCase_				)
      z_num //= hcf
      z_den //= hcf
      if 0 < z_num < z_den <= order:
       __snake_case         =			add_three(
           lowerCamelCase_ ,				lowerCamelCase_ ,				lowerCamelCase_ ,				lowerCamelCase_ ,				lowerCamelCase_ ,				lowerCamelCase_				)
       unique_s.add(lowerCamelCase_				)

                    # n=-1
     __snake_case         =			x_num * y_num
     __snake_case         =			x_den * y_num + x_num * y_den
     __snake_case         =			gcd(lowerCamelCase_ ,				lowerCamelCase_				)
     z_num //= hcf
     z_den //= hcf
     if 0 < z_num < z_den <= order:
      __snake_case         =			add_three(
          lowerCamelCase_ ,				lowerCamelCase_ ,				lowerCamelCase_ ,				lowerCamelCase_ ,				lowerCamelCase_ ,				lowerCamelCase_				)
      unique_s.add(lowerCamelCase_				)

     # n=2
     __snake_case         =			x_num * x_num * y_num * y_num
     __snake_case         =			(
         x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den
     )
     if is_sq(lowerCamelCase_				) and is_sq(lowerCamelCase_				):
      __snake_case         =			int(sqrt(lowerCamelCase_				)				)
      __snake_case         =			int(sqrt(lowerCamelCase_				)				)
      __snake_case         =			gcd(lowerCamelCase_ ,				lowerCamelCase_				)
      z_num //= hcf
      z_den //= hcf
      if 0 < z_num < z_den <= order:
       __snake_case         =			add_three(
           lowerCamelCase_ ,				lowerCamelCase_ ,				lowerCamelCase_ ,				lowerCamelCase_ ,				lowerCamelCase_ ,				lowerCamelCase_				)
       unique_s.add(lowerCamelCase_				)

 for num, den in unique_s:
  total += Fraction(lowerCamelCase_ ,				lowerCamelCase_				)

 return total.denominator + total.numerator


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






"""simple docstring"""







from random import randint, random

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							int     ,		lowerCamelCase_:							int     ,		lowerCamelCase_:							int     ,		lowerCamelCase_:							bool = False     ,		lowerCamelCase_:							bool = False     ,		lowerCamelCase_:							int = 5     ,		):
						"""simple docstring"""






						snake_case   :			str						    = [[-1] * number_of_cells]  # Create a highway without any car
						snake_case   :			str						    = 0
						snake_case   :			Any						    = max(lowerCamelCase_     ,		0 )
						while i < number_of_cells:
												snake_case   :			Optional[int]						    = (
												    randint(0     ,		lowerCamelCase_ ) if random_speed else initial_speed
												)  # Place the cars
												i += (
												    randint(1     ,		max_speed * 2 ) if random_frequency else frequency
												)  # Arbitrary number, may need tuning
						return highway

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							list     ,		lowerCamelCase_:							int ):
						"""simple docstring"""






						snake_case   :			Any						    = 0
						snake_case   :			int						    = highway_now[car_index + 1 :]
						for cell in range(len(lowerCamelCase_ ) ):  # May need a better name for this
												if cells[cell] != -1:  # If the cell is not empty then
																		return distance  # we have the distance we wanted
												distance += 1
						# Here if the car is near the end of the highway
						return distance + get_distance(lowerCamelCase_     ,		-1 )

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							list     ,		lowerCamelCase_:							float     ,		lowerCamelCase_:							int ):
						"""simple docstring"""






						snake_case   :			List[str]						    = len(lowerCamelCase_ )
						# Beforce calculations, the highway is empty
						snake_case   :			Dict						    = [-1] * number_of_cells

						for car_index in range(lowerCamelCase_ ):
												if highway_now[car_index] != -1:
																		# Add 1 to the current speed of the car and cap the speed
																		snake_case   :			Tuple						    = min(highway_now[car_index] + 1     ,		lowerCamelCase_ )
																		# Number of empty cell before the next car
																		snake_case   :			int						    = get_distance(lowerCamelCase_     ,		lowerCamelCase_ ) - 1
																		# We can't have the car causing an accident
																		snake_case   :			str						    = min(next_highway[car_index]     ,		lowerCamelCase_ )
																		if random() < probability:
																								# Randomly, a driver will slow down
																								snake_case   :			Optional[Any]						    = max(next_highway[car_index] - 1     ,		0 )
						return next_highway

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							list     ,		lowerCamelCase_:							int     ,		lowerCamelCase_:							float     ,		lowerCamelCase_:							int ):
						"""simple docstring"""






						snake_case   :			Optional[Any]						    = len(highway[0] )

						for i in range(lowerCamelCase_ ):
												snake_case   :			Union[str, Any]						    = update(highway[i]     ,		lowerCamelCase_     ,		lowerCamelCase_ )
												snake_case   :			Optional[int]						    = [-1] * number_of_cells

												for car_index in range(lowerCamelCase_ ):
																		snake_case   :			List[Any]						    = next_speeds_calculated[car_index]
																		if speed != -1:
																								# Change the position based on the speed (with % to create the loop)
																								snake_case   :			Optional[Any]						    = (car_index + speed) % number_of_cells
																								# Commit the change of position
																								snake_case   :			Tuple						    = speed
												highway.append(lowerCamelCase_ )

						return highway


if __name__ == "__main__":
			import doctest

			doctest.testmod()



