from __future__ import annotations

from fractions import Fraction
from math import gcd, sqrt




def 				UpperCamelCase						(       __lowercase						: int	):
		'''simple docstring'''




		A_		:				List[str]     =      int(number**0.5	)
		return number == sq * sq




def 				UpperCamelCase						(       __lowercase						: str						,__lowercase						: Optional[Any]						,__lowercase						: int						,__lowercase						: Union[str, Any]						,__lowercase						: Any						,__lowercase						: str	):
		'''simple docstring'''




		A_		:				Union[str, Any]     =      x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den
		A_		:				Union[str, Any]     =      x_den * y_den * z_den
		A_		:				Optional[int]     =      gcd(a_						,a_	)
		top //= hcf
		bottom //= hcf
		return top, bottom




def 				UpperCamelCase						(       __lowercase						: str = 35	):
		'''simple docstring'''




		A_		:				Tuple     =      set()
		A_		:				Dict     =      42
		A_		:				Any     =      Fraction(0	)
		A_		:				Union[str, Any]     =      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
										A_		:				Tuple     =      x_num * y_den + x_den * y_num
										A_		:				int     =      x_den * y_den
										A_		:				List[Any]     =      gcd(a_						,a_	)
										z_num //= hcf
										z_den //= hcf
										if 0 < z_num < z_den <= order:
												A_		:				Dict     =      add_three(
												    a_						,a_						,a_						,a_						,a_						,a_	)
												unique_s.add(a_	)

										# n=2
										A_		:				int     =      (
										    x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num
										)
										A_		:				Dict     =      x_den * x_den * y_den * y_den
										if is_sq(a_	) and is_sq(a_	):
												A_		:				Tuple     =      int(sqrt(a_	)	)
												A_		:				Union[str, Any]     =      int(sqrt(a_	)	)
												A_		:				Optional[Any]     =      gcd(a_						,a_	)
												z_num //= hcf
												z_den //= hcf
												if 0 < z_num < z_den <= order:
														A_		:				str     =      add_three(
														    a_						,a_						,a_						,a_						,a_						,a_	)
														unique_s.add(a_	)

                    # n=-1
										A_		:				Optional[int]     =      x_num * y_num
										A_		:				Optional[int]     =      x_den * y_num + x_num * y_den
										A_		:				int     =      gcd(a_						,a_	)
										z_num //= hcf
										z_den //= hcf
										if 0 < z_num < z_den <= order:
												A_		:				Optional[Any]     =      add_three(
												    a_						,a_						,a_						,a_						,a_						,a_	)
												unique_s.add(a_	)

										# n=2
										A_		:				List[Any]     =      x_num * x_num * y_num * y_num
										A_		:				Dict     =      (
										    x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den
										)
										if is_sq(a_	) and is_sq(a_	):
												A_		:				List[Any]     =      int(sqrt(a_	)	)
												A_		:				Any     =      int(sqrt(a_	)	)
												A_		:				Any     =      gcd(a_						,a_	)
												z_num //= hcf
												z_den //= hcf
												if 0 < z_num < z_den <= order:
														A_		:				Optional[Any]     =      add_three(
														    a_						,a_						,a_						,a_						,a_						,a_	)
														unique_s.add(a_	)

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

		return total.denominator + total.numerator


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








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available


SCREAMING_SNAKE_CASE							:List[Any]							 =				{}

try:
					if not is_sentencepiece_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE							:List[str]							 =				['BartphoTokenizer']

if TYPE_CHECKING:
					try:
										if not is_sentencepiece_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_bartpho import BartphoTokenizer

else:
					import sys

					SCREAMING_SNAKE_CASE							:Union[str, Any]							 =				_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
