



import numpy as np

lowercase_  =   [
    ['''a''', '''b''', '''c''', '''d''', '''e'''],
    ['''f''', '''g''', '''h''', '''i''', '''k'''],
    ['''l''', '''m''', '''n''', '''o''', '''p'''],
    ['''q''', '''r''', '''s''', '''t''', '''u'''],
    ['''v''', '''w''', '''x''', '''y''', '''z'''],
]
class  _snake_case	:




				def __init__(  self    :  Tuple  ):
							lowercase__         = np.array(__lowercase  )




				def 							A__					(  self    :  Optional[int],    __lowercase    :  str  ):
							lowercase__         = np.where(letter == self.SQUARE  )
							lowercase__         = np.concatenate([indexa + 1, indexa + 1]  )
							return indexes




				def 							A__					(  self    :  List[Any],    __lowercase    :  int,    __lowercase    :  int  ):
							return self.SQUARE[indexa - 1, indexa - 1]




				def 							A__					(  self    :  Optional[int],    __lowercase    :  str  ):
							lowercase__         = message.lower()
							lowercase__         = message.replace("j",    "i"  )

							lowercase__         = ''
							for letter_index in range(len(__lowercase  )  ):
										if message[letter_index] != " ":
													lowercase__         = self.letter_to_numbers(message[letter_index]  )
													lowercase__         = encoded_message + str(numbers[0]  ) + str(numbers[1]  )
										elif message[letter_index] == " ":
													lowercase__         = encoded_message + ' '

							return encoded_message




				def 							A__					(  self    :  Optional[Any],    __lowercase    :  str  ):
							lowercase__         = message.replace(" ",    "  "  )
							lowercase__         = ''
							for numbers_index in range(int(len(__lowercase  ) / 2  )  ):
										if message[numbers_index * 2] != " ":
													lowercase__         = message[numbers_index * 2]
													lowercase__         = message[numbers_index * 2 + 1]

													lowercase__         = self.numbers_to_letter(int(__lowercase  ),    int(__lowercase  )  )
													lowercase__         = decoded_message + letter
										elif message[numbers_index * 2] == " ":
													lowercase__         = decoded_message + ' '

							return decoded_message








'''simple docstring'''







import sys

sys.set_int_max_str_digits(0)  # type: ignore






def       lowerCAmelCase__       (				lowerCamelCase     :			int   ):
       _A     :	Optional[Any]      =					[0] * 11
       _A     :	str      =					[0] * 11

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

       # check last 9 numbers for pandigitality

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

       # mark first 9 numbers
       _A     :	Optional[int]      =					int(str(lowerCamelCase   )[:9]   )

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

       # check first 9 numbers for pandigitality

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






def       lowerCAmelCase__       (				lowerCamelCase     :			int   ):
       _A     :	Dict      =					[0] * 11

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

       # check last 9 numbers for pandigitality

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






def       lowerCAmelCase__       (				):
       _A     :	List[Any]      =					1
       _A     :	Dict      =					1
       _A     :	Dict      =					2
       # temporary Fibonacci numbers

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

       # mod m=1e9, done for fast optimisation
       _A     :	Tuple      =					[0] * 1000000
       _A     :	Any      =					1000000000

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

       for x in range(1000000   ):
              _A     :	List[str]      =					a + b
              _A     :	Optional[int]      =					b
              _A     :	str      =					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() = }""")






