





"""simple docstring"""
from __future__ import annotations




def 			__snake_case						(      __A ,__A ,__A    )		->				int:
   assert n > 1 and a > 0 and greatest_common_divisor(__A ,__A    ) == 1
   ((lowercase)  ,					(lowercase)  ,					(lowercase))    :			Any  =       extended_gcd(__A ,__A    )  # Implemented below
   lowercase    :			Tuple  =       (b * s) % n
   return x




def 			__snake_case						(      __A ,__A    )		->				int:
   ((lowercase)  ,					(lowercase))    :			Any  =       extended_euclid(__A ,__A    )  # Implemented below
   if b < 0:
      lowercase    :			Optional[int]  =       (b % n + n) % n
   return b




def 			__snake_case						(      __A ,__A ,__A    )		->				int:
   lowercase    :			Optional[Any]  =       invert_modulo(__A ,__A    )
   lowercase    :			Dict  =       (b * s) % n
   return x




def 			__snake_case						(      __A ,__A    )		->				tuple[int, int, int]:
   assert a >= 0 and b >= 0

   if b == 0:
      lowercase  ,					lowercase  ,					lowercase    :			Optional[Any]  =       a, 1, 0
   else:
      ((lowercase)  ,					(lowercase)  ,					(lowercase))    :			int  =       extended_gcd(__A ,a % b    )
      lowercase    :			Any  =       q
      lowercase    :			List[Any]  =       p - q * (a // b)

   assert a % d == 0 and b % d == 0
   assert d == a * x + b * y

   return (d, x, y)




def 			__snake_case						(      __A ,__A    )		->				tuple[int, int]:
   if b == 0:
      return (1, 0)
   ((lowercase)  ,					(lowercase))    :			Any  =       extended_euclid(__A ,a % b    )
   lowercase    :			List[Any]  =       a // b
   return (y, x - k * y)




def 			__snake_case						(      __A ,__A    )		->				int:
   if a < b:
      lowercase  ,					lowercase    :			List[Any]  =       b, a

   while a % b != 0:
      lowercase  ,					lowercase    :			Union[str, Any]  =       b, a % b

   return b


if __name__ == "__main__":
   from doctest import testmod

   testmod(name="modular_division", verbose=True)
   testmod(name="modular_division2", verbose=True)
   testmod(name="invert_modulo", verbose=True)
   testmod(name="extended_gcd", verbose=True)
   testmod(name="extended_euclid", verbose=True)
   testmod(name="greatest_common_divisor", verbose=True)









"""simple docstring"""
import math




def 			__snake_case						(      __A    )		->				float:
   lowercase    :			List[Any]  =       math.log(2 ,10    ) * number
   lowercase    :			Tuple  =       round((log_number - int(__A    )) ,15    )

   return difference




def 			__snake_case						(      __A = 678910    )		->				int:
   lowercase    :			Any  =       90
   lowercase    :			Optional[Any]  =       0

   lowercase    :			List[str]  =       math.log(1.23 ,10    )
   lowercase    :			str  =       math.log(1.24 ,10    )
   lowercase    :			str  =       0

   while position < number:
      lowercase    :			Optional[Any]  =       log_difference(__A    )

      if difference >= upper_limit:
         power_iterator += 93

      elif difference < lower_limit:
         power_iterator += 196

      else:
         lowercase    :			List[Any]  =       power_iterator
         power_iterator += 196
         position += 1

   return previous_power


if __name__ == "__main__":
   import doctest

   doctest.testmod()

   print(F'{solution() = }')


