






import sys

sys.set_int_max_str_digits(0)  # type: ignore

def    _lowerCamelCase		(  __A			:							int       )					->    Dict:
    _UpperCAmelCase :					Optional[Any]	     = [0] * 11
    _UpperCAmelCase :					str	     = [0] * 11

    # mark last 9 numbers
    for _ in range(9       ):
        _UpperCAmelCase :					int	     = 1
        _UpperCAmelCase :					Optional[int]	     = number // 10
    # flag
    _UpperCAmelCase :					List[Any]	     = True

    # check last 9 numbers for pandigitality

    for x in range(9       ):
        if not check_last[x + 1]:
            _UpperCAmelCase :					Optional[int]	     = False
    if not f:
        return f

    # mark first 9 numbers
    _UpperCAmelCase :					Optional[int]	     = int(str(__A       )[:9]       )

    for _ in range(9       ):
        _UpperCAmelCase :					Optional[Any]	     = 1
        _UpperCAmelCase :					str	     = number // 10

    # check first 9 numbers for pandigitality

    for x in range(9       ):
        if not check_front[x + 1]:
            _UpperCAmelCase :					Optional[Any]	     = False
    return f

def    _lowerCamelCase		(  __A			:							int       )					->    Tuple:
    _UpperCAmelCase :					Dict	     = [0] * 11

    # mark last 9 numbers
    for _ in range(9       ):
        _UpperCAmelCase :					List[str]	     = 1
        _UpperCAmelCase :					Dict	     = number // 10
    # flag
    _UpperCAmelCase :					Optional[int]	     = True

    # check last 9 numbers for pandigitality

    for x in range(9       ):
        if not check_last[x + 1]:
            _UpperCAmelCase :					List[str]	     = False
    return f

def    _lowerCamelCase		(  )					->    Tuple:
    _UpperCAmelCase :					List[Any]	     = 1
    _UpperCAmelCase :					Dict	     = 1
    _UpperCAmelCase :					Dict	     = 2
    # temporary Fibonacci numbers

    _UpperCAmelCase :					List[Any]	     = 1
    _UpperCAmelCase :					Union[str, Any]	     = 1
    _UpperCAmelCase :					List[Any]	     = 2
    # temporary Fibonacci numbers mod 1e9

    # mod m=1e9, done for fast optimisation
    _UpperCAmelCase :					Tuple	     = [0] * 1_000_000
    _UpperCAmelCase :					Any	     = 1_000_000_000

    for x in range(1_000_000       ):
        _UpperCAmelCase :					Tuple	     = (aa + ba) % m
        _UpperCAmelCase :					Optional[Any]	     = ba % m
        _UpperCAmelCase :					str	     = ca % m
        if checka(__A       ):
            _UpperCAmelCase :					Dict	     = 1

    for x in range(1_000_000       ):
        _UpperCAmelCase :					List[str]	     = a + b
        _UpperCAmelCase :					Optional[int]	     = b
        _UpperCAmelCase :					str	     = c
        # perform check only if in tocheck
        if tocheck[x + 3] and check(__A       ):
            return x + 3  # first 2 already done
    return -1


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








'''simple docstring'''







import math






def       lowerCAmelCase__       (				lowerCamelCase     :			int   ):
       _A     :	int      =					math.log(2  ,10   ) * number
       _A     :	List[Any]      =					round((log_number - int(lowerCamelCase   ))  ,15   )

       return difference






def       lowerCAmelCase__       (				lowerCamelCase     :			int = 678910   ):
       _A     :	List[str]      =					90
       _A     :	List[Any]      =					0

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

       while position < number:
              _A     :	Dict      =					log_difference(lowerCamelCase   )

              if difference >= upper_limit:
                     power_iterator += 93

              elif difference < lower_limit:
                     power_iterator += 196

              else:
                     _A     :	str      =					power_iterator
                     power_iterator += 196
                     position += 1

       return previous_power


if __name__ == "__main__":
   import doctest

   doctest.testmod()

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






