





_SCREAMING_SNAKE_CASE   						=		10_00


def 				SCREAMING_SNAKE_CASE__    (     __a ):
	return x * x


def 				SCREAMING_SNAKE_CASE__    (     __a ,			__a ,			__a ,			__a = 4 ):
	assert callable(
	    __a ), f"""the function(object) passed should be callable your input : {function}"""
	assert isinstance(__a ,			(float, int) ), f"""a should be float or integer your input : {a}"""
	assert isinstance(function(__a ) ,			(float, int) ), (
	    "the function should return integer or float return type of your function, "
	    f"""{type(__a )}"""
	)
	assert isinstance(__a ,			(float, int) ), f"""b should be float or integer your input : {b}"""
	assert (
	    isinstance(__a ,			__a ) and precision > 0
	), f"""precision should be positive integer your input : {precision}"""

	# just applying the formula of simpson for approximate integration written in
	# mentioned article in first comment of this file and above this function

	snake_case_		:      int           =						(b - a) / N_STEPS
	snake_case_		:      Dict           =						function(__a ) + function(__a )

	for i in range(1 ,			__a ):
		snake_case_		:      Optional[Any]           =						a + h * i
		result += function(__a ) * (4 if i % 2 else 2)

	result *= h / 3
	return round(__a ,			__a )


if __name__ == "__main__":
						import doctest

						doctest.testmod()






"""simple docstring"""




from __future__ import annotations


def 	lowercase__  (      _UpperCAmelCase					)  ->      list[int]:






      '''simple docstring'''


      lowercase	:   Optional[Any]											= [0] * max_one

      for i in range(0						,   _UpperCAmelCase					):
            lowercase	:   List[Any]											= i

      for i in range(2						,   _UpperCAmelCase					):
            if totients[i] == i:
                  for j in range(_UpperCAmelCase						,   _UpperCAmelCase						,   _UpperCAmelCase					):
                        totients[j] -= totients[j] // i

      return totients


def 	lowercase__  (      _UpperCAmelCase						,   _UpperCAmelCase					)  ->      bool:






      '''simple docstring'''


      return sorted(str(_UpperCAmelCase					)					) == sorted(str(_UpperCAmelCase					)					)


def 	lowercase__  (      _UpperCAmelCase = 10_00_00_00					)  ->      int:






      '''simple docstring'''


      lowercase	:   Union[str, Any]											= 1  # i
      lowercase	:   Any											= 0  # φ(i)
      lowercase	:   int											= get_totients(max_n + 1					)

      for i in range(2						,   max_n + 1					):
            lowercase	:   Any											= totients[i]

            if i * min_denominator < min_numerator * t and has_same_digits(_UpperCAmelCase						,   _UpperCAmelCase					):
                  lowercase	:   List[Any]											= i
                  lowercase	:   Optional[Any]											= t

      return min_numerator


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