


'''simple docstring'''



import numpy as np

__UpperCAmelCase    :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 			a       :


     """simple docstring"""






     def __init__(       self  :	List[str]    )		->							None:
          __UpperCAmelCase			:				int													=    np.array(snake_case    )

     def 				lowerCamelCase__				(       self  :	List[Any]							,				snake_case  :	str    )		->							np.ndarray:
          __UpperCAmelCase							,     __UpperCAmelCase			:				Tuple													=    np.where(letter == self.SQUARE    )
          __UpperCAmelCase			:				str													=    np.concatenate([indexa + 1, indexa + 1]    )
          return indexes

     def 				lowerCamelCase__				(       self  :	Any							,				snake_case  :	int							,				snake_case  :	int    )		->							str:
          __UpperCAmelCase			:				Any													=    self.SQUARE[indexa - 1, indexa - 1]
          return letter

     def 				lowerCamelCase__				(       self  :	str							,				snake_case  :	str    )		->							str:
          __UpperCAmelCase			:				int													=    message.lower()
          __UpperCAmelCase			:				Optional[int]													=    message.replace(''' '''							,				''''''    )
          __UpperCAmelCase			:				List[str]													=    message.replace('''j'''							,				'''i'''    )

          __UpperCAmelCase			:				Union[str, Any]													=    np.empty((2, len(snake_case    ))    )
          for letter_index in range(len(snake_case    )    ):
               __UpperCAmelCase			:				str													=    self.letter_to_numbers(message[letter_index]    )

               __UpperCAmelCase			:				Tuple													=    numbers[0]
               __UpperCAmelCase			:				Union[str, Any]													=    numbers[1]

          __UpperCAmelCase			:				List[str]													=    first_step.reshape(2 * len(snake_case    )    )
          __UpperCAmelCase			:				Any													=    ''''''
          for numbers_index in range(len(snake_case    )    ):
               __UpperCAmelCase			:				Any													=    int(second_step[numbers_index * 2]    )
               __UpperCAmelCase			:				int													=    int(second_step[(numbers_index * 2) + 1]    )
               __UpperCAmelCase			:				str													=    self.numbers_to_letter(snake_case							,				snake_case    )
               __UpperCAmelCase			:				int													=    encoded_message + letter

          return encoded_message






     def 				lowerCamelCase__				(       self  :	Union[str, Any]							,				snake_case  :	str    )		->							str:
          __UpperCAmelCase			:				Dict													=    message.lower()
          message.replace(''' '''							,				''''''    )
          __UpperCAmelCase			:				List[Any]													=    np.empty(2 * len(snake_case    )    )
          for letter_index in range(len(snake_case    )    ):
               __UpperCAmelCase			:				List[str]													=    self.letter_to_numbers(message[letter_index]    )
               __UpperCAmelCase			:				Dict													=    numbers[0]
               __UpperCAmelCase			:				str													=    numbers[1]

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

          return decoded_message



'''simple docstring'''



from __future__ import annotations




def 			_a			(		_lowercase      :			int						):





     '''simple docstring'''






     __UpperCAmelCase			:				str													=    [True] * limit
     __UpperCAmelCase			:				Tuple													=    False
     __UpperCAmelCase			:				List[str]													=    False
     __UpperCAmelCase			:				List[Any]													=    True

     for i in range(3    ,      int(limit**0.5 + 1						)    ,      2						):
          __UpperCAmelCase			:				Dict													=    i * 2
          while index < limit:
               __UpperCAmelCase			:				Optional[int]													=    False
               __UpperCAmelCase			:				Union[str, Any]													=    index + i

     __UpperCAmelCase			:				Optional[Any]													=    [2]

     for i in range(3    ,      _lowercase    ,      2						):
          if is_prime[i]:
               primes.append(_lowercase						)

     return primes




def 			_a			(		_lowercase      :			int = 1000000						):





     '''simple docstring'''






     __UpperCAmelCase			:				List[str]													=    prime_sieve(_lowercase						)
     __UpperCAmelCase			:				Optional[Any]													=    0
     __UpperCAmelCase			:				int													=    0

     for i in range(len(_lowercase						)						):
          for j in range(i + length    ,      len(_lowercase						)						):
               __UpperCAmelCase			:				Optional[Any]													=    sum(primes[i:j]						)
               if sol >= ceiling:
                    break

               if sol in primes:
                    __UpperCAmelCase			:				Any													=    j - i
                    __UpperCAmelCase			:				List[Any]													=    sol

     return largest


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