


'''simple docstring'''







from __future__ import annotations






def 			lowercase				(_A					):







       """simple docstring"""







       _lowerCAmelCase    :							List[Any]   			=       [True] * limit
       _lowerCAmelCase    :							Optional[int]   			=       False
       _lowerCAmelCase    :							Dict   			=       False
       _lowerCAmelCase    :							Optional[Any]   			=       True

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

       _lowerCAmelCase    :							Dict   			=       [2]

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

       return primes






def 			lowercase				(_A = 1_0_0_0_0_0_0					):







       """simple docstring"""







       _lowerCAmelCase    :							List[Any]   			=       prime_sieve(_A					)
       _lowerCAmelCase    :							Optional[Any]   			=       0
       _lowerCAmelCase    :							Any   			=       0

       for i in range(len(_A					)					):
              for j in range(i + length   ,						len(_A					)					):
                     _lowerCAmelCase    :							List[str]   			=       sum(primes[i:j]					)
                     if sol >= ceiling:
                            break

                     if sol in primes:
                            _lowerCAmelCase    :							Union[str, Any]   			=       j - i
                            _lowerCAmelCase    :							str   			=       sol

       return largest


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





'''simple docstring'''







from collections import Counter
from timeit import timeit






def 			lowercase				(_A = ""   ,						):







       """simple docstring"""







       return sum(c % 2 for c in Counter(input_str.replace(' '   ,						''					).lower()					).values()					) < 2






def 			lowercase				(_A = ""					):







       """simple docstring"""







       if len(_A					) == 0:
              return True
       _lowerCAmelCase    :							Union[str, Any]   			=       input_str.replace(' '   ,						''					).lower()
       # character_freq_dict: Stores the frequency of every character in the input string
       _lowerCAmelCase    :							dict[str, int]   			=       {}

       for character in lower_case_input_str:
              _lowerCAmelCase    :							Union[str, Any]   			=       character_freq_dict.get(_A   ,						0					) + 1
       _lowerCAmelCase    :							List[Any]   			=       0

       for character_count in character_freq_dict.values():
              if character_count % 2:
                     odd_char += 1
       if odd_char > 1:
              return False
       return True






def 			lowercase				(_A = ""					):







       """simple docstring"""







       print('\nFor string = '   ,						_A   ,						':'					)
       print(
           '> can_string_be_rearranged_as_palindrome_counter()'   ,						'\tans ='   ,						can_string_be_rearranged_as_palindrome_counter(_A					)   ,						'\ttime ='   ,						timeit(
               'z.can_string_be_rearranged_as_palindrome_counter(z.check_str)'   ,						setup='import __main__ as z'   ,						)   ,						'seconds'   ,						)
       print(
           '> can_string_be_rearranged_as_palindrome()'   ,						'\tans ='   ,						can_string_be_rearranged_as_palindrome(_A					)   ,						'\ttime ='   ,						timeit(
               'z.can_string_be_rearranged_as_palindrome(z.check_str)'   ,						setup='import __main__ as z'   ,						)   ,						'seconds'   ,						)


if __name__ == "__main__":
       lowerCAmelCase    :     Tuple					=						input(
           """Enter string to determine if it can be rearranged as a palindrome or not: """
       ).strip()
       benchmark(check_str)
       lowerCAmelCase    :     Optional[Any]					=						can_string_be_rearranged_as_palindrome_counter(check_str)
       print(F'''{check_str} can {"" if status else "not "}be rearranged as a palindrome''')

