'''simple docstring'''

import sys

sys.set_int_max_str_digits(0)  # type: ignore


def __a			(						__lowerCamelCase      :    int					)						->				bool:
      '''simple docstring'''


      lowercase_     			=   [0] * 11
      lowercase_     			=   [0] * 11

      # mark last 9 numbers
      for _ in range(9					):
            lowercase_     			=   1
            lowercase_     			=   number // 10
      # flag
      lowercase_     			=   True

      # check last 9 numbers for pandigitality

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

      # mark first 9 numbers
      lowercase_     			=   int(str(__lowerCamelCase					)[:9]					)

      for _ in range(9					):
            lowercase_     			=   1
            lowercase_     			=   number // 10

      # check first 9 numbers for pandigitality

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


def __a			(						__lowerCamelCase      :    int					)						->				bool:
      '''simple docstring'''


      lowercase_     			=   [0] * 11

      # mark last 9 numbers
      for _ in range(9					):
            lowercase_     			=   1
            lowercase_     			=   number // 10
      # flag
      lowercase_     			=   True

      # check last 9 numbers for pandigitality

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


def __a			(						)						->				int:
      '''simple docstring'''


      lowercase_     			=   1
      lowercase_     			=   1
      lowercase_     			=   2
      # temporary Fibonacci numbers

      lowercase_     			=   1
      lowercase_     			=   1
      lowercase_     			=   2
      # temporary Fibonacci numbers mod 1e9

      # mod m=1e9, done for fast optimisation
      lowercase_     			=   [0] * 1_000_000
      lowercase_     			=   1_000_000_000

      for x in range(1_000_000					):
            lowercase_     			=   (aa + ba) % m
            lowercase_     			=   ba % m
            lowercase_     			=   ca % m
            if checka(__lowerCamelCase					):
                  lowercase_     			=   1

      for x in range(1_000_000					):
            lowercase_     			=   a + b
            lowercase_     			=   b
            lowercase_     			=   c
            # perform check only if in tocheck
            if tocheck[x + 3] and check(__lowerCamelCase					):
                  return x + 3  # first 2 already done
      return -1


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







'''simple docstring'''

import timeit





class 				lowercase    :


   def __init__( self					:						Dict ,		__lowerCAmelCase					:						Any)   ->       Optional[int]:
         if isinstance(__lowerCAmelCase ,		__lowerCAmelCase):  # Initializes a matrix identical to the one provided.
               lowercase_     			=   arg
               lowercase_     			=   len(__lowerCAmelCase)
         else:  # Initializes a square matrix of the given size and set values to zero.
               lowercase_     			=   arg
               lowercase_     			=   [[0 for _ in range(self.n)] for _ in range(self.n)]


   def __mul__( self					:						int ,		__lowerCAmelCase					:						List[str])   ->       Union[str, Any]:
         lowercase_     			=   Matrix(self.n)
         for i in range(self.n):
               for j in range(self.n):
                     for k in range(self.n):
                           matrix.t[i][j] += self.t[i][k] * b.t[k][j]
         return matrix




def __a			(						__lowerCamelCase      :    List[str]			,		__lowerCamelCase      :    Dict					)						->				Optional[Any]:
      '''simple docstring'''


      lowercase_     			=   Matrix([[1, 0], [0, 1]]					)
      while b > 0:
            if b & 1:
                  matrix *= a
            a *= a
            b >>= 1
      return matrix


def __a			(						__lowerCamelCase      :    Tuple			,		__lowerCamelCase      :    Tuple			,		__lowerCamelCase      :    List[Any]					)						->				Dict:
      '''simple docstring'''


      if n == 1:
            return fa
      elif n == 2:
            return fa
      lowercase_     			=   Matrix([[1, 1], [1, 0]]					)
      lowercase_     			=   modular_exponentiation(__lowerCamelCase			,		n - 2					)
      return fa * matrix.t[0][0] + fa * matrix.t[0][1]


def __a			(						__lowerCamelCase      :    List[Any]			,		__lowerCamelCase      :    Union[str, Any]			,		__lowerCamelCase      :    List[str]					)						->				Optional[Any]:
      '''simple docstring'''


      if n == 1:
            return fa
      elif n == 2:
            return fa

      lowercase_     			=   fa
      lowercase_     			=   fa
      n -= 2

      while n > 0:
            lowercase_			,				lowercase_     			=   fn_a + fn_a, fn_a
            n -= 1

      return fn_a


def __a			(						)						->				str:
      '''simple docstring'''


      lowercase_     			=   "\nfrom random import randint\nfrom __main__ import fibonacci_with_matrix_exponentiation\n"
      lowercase_     			=   "fibonacci_with_matrix_exponentiation(randint(1,70000), 1, 1)"
      lowercase_     			=   timeit.timeit(setup=__lowerCamelCase			,		stmt=__lowerCamelCase			,		number=100					)
      print("With matrix exponentiation the average execution time is "			,		exec_time / 100					)
      return exec_time


def __a			(						)						->				Optional[Any]:
      '''simple docstring'''


      lowercase_     			=   "\nfrom random import randint\nfrom __main__ import simple_fibonacci\n"
      lowercase_     			=   "simple_fibonacci(randint(1,70000), 1, 1)"
      lowercase_     			=   timeit.timeit(setup=__lowerCamelCase			,		stmt=__lowerCamelCase			,		number=100					)
      print(
          "Without matrix exponentiation the average execution time is "			,		exec_time / 100					)
      return exec_time


def __a			(						)						->				Tuple:
      '''simple docstring'''


      matrix_exponentiation_time()
      simple_fibonacci_time()


if __name__ == "__main__":
       main()






