





import sys

sys.set_int_max_str_digits(0)  # type: ignore






def 				_lowerCAmelCase			(	_a :       int      )						->      bool:
     lowerCAmelCase_       :							Optional[int]			 =		[0] * 11
     lowerCAmelCase_       :							Dict			 =		[0] * 11

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

     # check last 9 numbers for pandigitality

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

     # mark first 9 numbers
     lowerCAmelCase_       :							str			 =		int(str(_a      )[:9]      )

     for _ in range(9      ):
          lowerCAmelCase_       :							List[Any]			 =		1
          lowerCAmelCase_       :							Optional[int]			 =		number // 10

     # check first 9 numbers for pandigitality

     for x in range(9      ):
          if not check_front[x + 1]:
               lowerCAmelCase_       :							Union[str, Any]			 =		False
     return f






def 				_lowerCAmelCase			(	_a :       int      )						->      bool:
     lowerCAmelCase_       :							str			 =		[0] * 11

     # mark last 9 numbers
     for _ in range(9      ):
          lowerCAmelCase_       :							Union[str, Any]			 =		1
          lowerCAmelCase_       :							Dict			 =		number // 10
     # flag
     lowerCAmelCase_       :							List[Any]			 =		True

     # check last 9 numbers for pandigitality

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






def 				_lowerCAmelCase			(	)						->      int:
     lowerCAmelCase_       :							Optional[Any]			 =		1
     lowerCAmelCase_       :							List[Any]			 =		1
     lowerCAmelCase_       :							Optional[Any]			 =		2
     # temporary Fibonacci numbers

     lowerCAmelCase_       :							Any			 =		1
     lowerCAmelCase_       :							Dict			 =		1
     lowerCAmelCase_       :							List[Any]			 =		2
     # temporary Fibonacci numbers mod 1e9

     # mod m=1e9, done for fast optimisation
     lowerCAmelCase_       :							Optional[int]			 =		[0] * 1_00_00_00
     lowerCAmelCase_       :							Any			 =		10_00_00_00_00

     for x in range(1_00_00_00      ):
          lowerCAmelCase_       :							List[str]			 =		(aa + ba) % m
          lowerCAmelCase_       :							List[str]			 =		ba % m
          lowerCAmelCase_       :							Optional[Any]			 =		ca % m
          if checka(_a      ):
               lowerCAmelCase_       :							Any			 =		1

     for x in range(1_00_00_00      ):
          lowerCAmelCase_       :							int			 =		a + b
          lowerCAmelCase_       :							List[Any]			 =		b
          lowerCAmelCase_       :							Dict			 =		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() = }""")







import numpy as np






def 				_lowerCAmelCase			(	_a :       Optional[int]       , _a :       str      )						->      Union[str, Any]:
     lowerCAmelCase_       :							int			 =		np.array(_a      )
     lowerCAmelCase_       :							str			 =		np.array(_a      )

     lowerCAmelCase_       :							Optional[Any]			 =		abs(predict - actual      )
     lowerCAmelCase_       :							Dict			 =		difference.mean()

     return score






def 				_lowerCAmelCase			(	_a :       Union[str, Any]       , _a :       int      )						->      Tuple:
     lowerCAmelCase_       :							int			 =		np.array(_a      )
     lowerCAmelCase_       :							int			 =		np.array(_a      )

     lowerCAmelCase_       :							Union[str, Any]			 =		predict - actual
     lowerCAmelCase_       :							Tuple			 =		np.square(_a      )

     lowerCAmelCase_       :							Tuple			 =		square_diff.mean()
     return score






def 				_lowerCAmelCase			(	_a :       Optional[Any]       , _a :       Tuple      )						->      Optional[int]:
     lowerCAmelCase_       :							Optional[Any]			 =		np.array(_a      )
     lowerCAmelCase_       :							Optional[Any]			 =		np.array(_a      )

     lowerCAmelCase_       :							int			 =		predict - actual
     lowerCAmelCase_       :							Any			 =		np.square(_a      )
     lowerCAmelCase_       :							Union[str, Any]			 =		square_diff.mean()
     lowerCAmelCase_       :							Optional[Any]			 =		np.sqrt(_a      )
     return score






def 				_lowerCAmelCase			(	_a :       Optional[Any]       , _a :       Optional[Any]      )						->      List[Any]:
     lowerCAmelCase_       :							Dict			 =		np.array(_a      )
     lowerCAmelCase_       :							List[Any]			 =		np.array(_a      )

     lowerCAmelCase_       :							str			 =		np.log(predict + 1      )
     lowerCAmelCase_       :							Any			 =		np.log(actual + 1      )

     lowerCAmelCase_       :							List[str]			 =		log_predict - log_actual
     lowerCAmelCase_       :							Dict			 =		np.square(_a      )
     lowerCAmelCase_       :							Optional[Any]			 =		square_diff.mean()

     lowerCAmelCase_       :							int			 =		np.sqrt(_a      )

     return score






def 				_lowerCAmelCase			(	_a :       str       , _a :       List[Any]      )						->      int:
     lowerCAmelCase_       :							Any			 =		np.array(_a      )
     lowerCAmelCase_       :							Optional[int]			 =		np.array(_a      )

     lowerCAmelCase_       :							Optional[int]			 =		predict - actual
     lowerCAmelCase_       :							str			 =		np.sum(_a      ) / len(_a      )
     lowerCAmelCase_       :							List[str]			 =		np.sum(_a      ) / len(_a      )
     # print(numerator, denumerator)
     lowerCAmelCase_       :							int			 =		float(_a      ) / denumerator * 1_00

     return score







def 				_lowerCAmelCase			(	_a :       Any       , _a :       Union[str, Any]      )						->      str:
     return np.mean(np.array(_a      ) == np.array(_a      )      )
