


from __future__ import annotations

from fractions import Fraction
from math import gcd, sqrt


def     _SCREAMING_SNAKE_CASE      (					SCREAMING_SNAKE_CASE			):
  A_ :							int							=   int(number**0.5			)
  return number == sq * sq


def     _SCREAMING_SNAKE_CASE      (					SCREAMING_SNAKE_CASE					,     SCREAMING_SNAKE_CASE					,     SCREAMING_SNAKE_CASE					,     SCREAMING_SNAKE_CASE					,     SCREAMING_SNAKE_CASE					,     SCREAMING_SNAKE_CASE			):
  A_ :							int							=   x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den
  A_ :							int							=   x_den * y_den * z_den
  A_ :							int							=   gcd(_lowercase					,     _lowercase			)
  top //= hcf
  bottom //= hcf
  return top, bottom


def     _SCREAMING_SNAKE_CASE      (					SCREAMING_SNAKE_CASE = 35			):
  A_ :							set							=   set()
  A_ :							int
  A_ :							Fraction							=   Fraction(0			)
  A_ :							tuple[int, int]

  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_ :							str							=   x_num * y_den + x_den * y_num
          A_ :							Tuple							=   x_den * y_den
          A_ :							Optional[Any]							=   gcd(_lowercase					,     _lowercase			)
          z_num //= hcf
          z_den //= hcf
          if 0 < z_num < z_den <= order:
            A_ :							Dict							=   add_three(
                _lowercase					,     _lowercase					,     _lowercase					,     _lowercase					,     _lowercase					,     _lowercase			)
            unique_s.add(_lowercase			)

          # 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(_lowercase			) and is_sq(_lowercase			):
            A_ :							Optional[Any]							=   int(sqrt(_lowercase			)			)
            A_ :							Union[str, Any]							=   int(sqrt(_lowercase			)			)
            A_ :							Union[str, Any]							=   gcd(_lowercase					,     _lowercase			)
            z_num //= hcf
            z_den //= hcf
            if 0 < z_num < z_den <= order:
              A_ :							Dict							=   add_three(
                  _lowercase					,     _lowercase					,     _lowercase					,     _lowercase					,     _lowercase					,     _lowercase			)
              unique_s.add(_lowercase			)

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

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

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

  return total.denominator + total.numerator


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











from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__UpperCamelCase:	Optional[int] = logging.get_logger(__name__)

__UpperCamelCase:	Optional[int] = {
    """google/mobilenet_v1_1.0_224""": """https://huggingface.co/google/mobilenet_v1_1.0_224/resolve/main/config.json""",
    """google/mobilenet_v1_0.75_192""": """https://huggingface.co/google/mobilenet_v1_0.75_192/resolve/main/config.json""",
    # See all MobileNetV1 models at https://huggingface.co/models?filter=mobilenet_v1
}


class       __lowerCAmelCase					(       _UpperCamelCase      ):


	'''simple docstring'''





	_A													=				"mobilenet_v1"

	def __init__(						self:						Dict,					lowerCamelCase_:						Any=3,					lowerCamelCase_:						Dict=224,					lowerCamelCase_:						int=1.0,					lowerCamelCase_:						List[Any]=8,					lowerCamelCase_:						int="relu6",					lowerCamelCase_:						Optional[int]=True,					lowerCamelCase_:						Any=0.9_9_9,					lowerCamelCase_:						List[str]=0.0_2,					lowerCamelCase_:						Optional[int]=0.0_0_1,					**lowerCamelCase_:						Tuple,					):
			super().__init__(**lowerCamelCase_			)

			if depth_multiplier <= 0:
					raise ValueError('depth_multiplier must be greater than zero.'			)

			lowercase__					:      Optional[int]      =		num_channels
			lowercase__					:      List[Any]      =		image_size
			lowercase__					:      str      =		depth_multiplier
			lowercase__					:      Optional[Any]      =		min_depth
			lowercase__					:      int      =		hidden_act
			lowercase__					:      Dict      =		tf_padding
			lowercase__					:      Optional[Any]      =		classifier_dropout_prob
			lowercase__					:      int      =		initializer_range
			lowercase__					:      Any      =		layer_norm_eps


class       __lowerCAmelCase					(       _UpperCamelCase      ):


	'''simple docstring'''





	_A													=				version.parse("1.11"      )

	@property
	def    snake_case__(						self:						Optional[int]			):
			return OrderedDict([('pixel_values', {0: 'batch'})]			)

	@property
	def    snake_case__(						self:						Dict			):
			if self.task == "image-classification":
					return OrderedDict([('logits', {0: 'batch'})]			)
			else:
					return OrderedDict([('last_hidden_state', {0: 'batch'}), ('pooler_output', {0: 'batch'})]			)





	@property
	def    snake_case__(						self:						List[Any]			):
			return 1E-4


