'''simple docstring'''




from __future__ import annotations





def      _UpperCAmelCase    (							_UpperCamelCase    :	int,   _UpperCamelCase    :	int,   _UpperCamelCase    :	int   )	->      int:
    assert n > 1 and a > 0 and greatest_common_divisor(_UpperCamelCase,   _UpperCamelCase   ) == 1
    ((A_)   ,(A_)   ,(A_))     =   extended_gcd(_UpperCamelCase,   _UpperCamelCase   )  # Implemented below
    A_     =   (b * s) % n
    return x





def      _UpperCAmelCase    (							_UpperCamelCase    :	int,   _UpperCamelCase    :	int   )	->      int:
    ((A_)   ,(A_))     =   extended_euclid(_UpperCamelCase,   _UpperCamelCase   )  # Implemented below
    if b < 0:
        A_     =   (b % n + n) % n
    return b





def      _UpperCAmelCase    (							_UpperCamelCase    :	int,   _UpperCamelCase    :	int,   _UpperCamelCase    :	int   )	->      int:
    A_     =   invert_modulo(_UpperCamelCase,   _UpperCamelCase   )
    A_     =   (b * s) % n
    return x





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

    if b == 0:
        A_   ,A_   ,A_     =   a, 1, 0
    else:
        ((A_)   ,(A_)   ,(A_))     =   extended_gcd(_UpperCamelCase,   a % b   )
        A_     =   q
        A_     =   p - q * (a // b)

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

    return (d, x, y)





def      _UpperCAmelCase    (							_UpperCamelCase    :	int,   _UpperCamelCase    :	int   )	->      tuple[int, int]:
    if b == 0:
        return (1, 0)
    ((A_)   ,(A_))     =   extended_euclid(_UpperCamelCase,   a % b   )
    A_     =   a // b
    return (y, x - k * y)





def      _UpperCAmelCase    (							_UpperCamelCase    :	int,   _UpperCamelCase    :	int   )	->      int:
    if a < b:
        A_   ,A_     =   b, a

    while a % b != 0:
        A_   ,A_     =   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      _UpperCAmelCase    (							_UpperCamelCase    :	int   )	->      float:
    A_     =   math.log(2,   10   ) * number
    A_     =   round((log_number - int(_UpperCamelCase   )),   15   )

    return difference





def      _UpperCAmelCase    (							_UpperCamelCase    :	int = 67_89_10   )	->      int:
    A_     =   90
    A_     =   0

    A_     =   math.log(1.2_3,   10   )
    A_     =   math.log(1.2_4,   10   )
    A_     =   0

    while position < number:
        A_     =   log_difference(_UpperCamelCase   )

        if difference >= upper_limit:
            power_iterator += 93

        elif difference < lower_limit:
            power_iterator += 1_96

        else:
            A_     =   power_iterator
            power_iterator += 1_96
            position += 1

    return previous_power


if __name__ == "__main__":
  import doctest

  doctest.testmod()

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






