



import numpy as np

snake_case    :						Union[str, Any]  =						[
    ['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 							lowerCAmelCase__  :







     def __init__(       self      :     Dict):
           A__	:							Optional[int]						    = np.array(lowerCAmelCase_)







     def  _lowercase			(       self      :     List[Any]			,		_A      :     int):
           A__    ,       A__	:							int						    = np.where(letter == self.SQUARE)
           A__	:							List[Any]						    = np.concatenate([indexa + 1, indexa + 1])
           return indexes







     def  _lowercase			(       self      :     Optional[Any]			,		_A      :     str			,		_A      :     Optional[Any]):
           A__	:							Any						    = self.SQUARE[indexa - 1, indexa - 1]
           return letter







     def  _lowercase			(       self      :     List[str]			,		_A      :     int):
           A__	:							Any						    = message.lower()
           A__	:							Optional[Any]						    = message.replace(" "			,		"")
           A__	:							Optional[Any]						    = message.replace("j"			,		"i")

           A__	:							Optional[int]						    = np.empty((2, len(lowerCAmelCase_)))
           for letter_index in range(len(lowerCAmelCase_)):
                 A__	:							int						    = self.letter_to_numbers(message[letter_index])

                 A__	:							str						    = numbers[0]
                 A__	:							Optional[int]						    = numbers[1]

           A__	:							Optional[int]						    = first_step.reshape(2 * len(lowerCAmelCase_))
           A__	:							int						    = ""
           for numbers_index in range(len(lowerCAmelCase_)):
                 A__	:							Optional[Any]						    = int(second_step[numbers_index * 2])
                 A__	:							List[Any]						    = int(second_step[(numbers_index * 2) + 1])
                 A__	:							str						    = self.numbers_to_letter(lowerCAmelCase_			,		lowerCAmelCase_)
                 A__	:							Dict						    = encoded_message + letter

           return encoded_message







     def  _lowercase			(       self      :     List[str]			,		_A      :     List[Any]):
           A__	:							Union[str, Any]						    = message.lower()
           message.replace(" "			,		"")
           A__	:							Any						    = np.empty(2 * len(lowerCAmelCase_))
           for letter_index in range(len(lowerCAmelCase_)):
                 A__	:							int						    = self.letter_to_numbers(message[letter_index])
                 A__	:							Dict						    = numbers[0]
                 A__	:							Dict						    = numbers[1]

           A__	:							int						    = first_step.reshape((2, len(lowerCAmelCase_)))
           A__	:							Optional[int]						    = ""
           for numbers_index in range(len(lowerCAmelCase_)):
                 A__	:							Dict						    = int(second_step[0, numbers_index])
                 A__	:							Any						    = int(second_step[1, numbers_index])
                 A__	:							str						    = self.numbers_to_letter(lowerCAmelCase_			,		lowerCAmelCase_)
                 A__	:							Any						    = decoded_message + letter

           return decoded_message




def 	snake_case__       (					)		->		Union[str, Any]:







						"""simple docstring"""

						A__	:							Tuple						    = []
						A__	:							Optional[int]						    = 1

						while len(__lowercase       ) < 1E6:
												constant.append(str(__lowercase       )       )
												i += 1

						A__	:							Any						    = "".join(__lowercase       )

						return (
						    int(constant[0]       )
						    * int(constant[9]       )
						    * int(constant[9_9]       )
						    * int(constant[9_9_9]       )
						    * int(constant[9_9_9_9]       )
						    * int(constant[9_9_9_9_9]       )
						    * int(constant[9_9_9_9_9_9]       )
						)


if __name__ == "__main__":
		print(solution())