





from typing import Literal

_SCREAMING_SNAKE_CASE   						=		"""ABCDEFGHIJKLMNOPQRSTUVWXYZ"""


def 				SCREAMING_SNAKE_CASE__    (     __a ,			__a ,			__a ):
	snake_case_		:      List[str]           =						LETTERS if mode == 'decrypt' else key
	snake_case_		:      List[Any]           =						key if mode == 'decrypt' else LETTERS
	snake_case_		:      Any           =						''
	# loop through each symbol in the message
	for symbol in message:
		if symbol.upper() in chars_a:
			# encrypt/decrypt the symbol
			snake_case_		:      int           =						chars_a.find(symbol.upper() )
			if symbol.isupper():
				translated += chars_b[sym_index].upper()
			else:
				translated += chars_b[sym_index].lower()
		else:
			# symbol is not in LETTERS, just add it
			translated += symbol
	return translated


def 				SCREAMING_SNAKE_CASE__    (     __a ,			__a ):
	return translate_message(__a ,			__a ,			'encrypt' )


def 				SCREAMING_SNAKE_CASE__    (     __a ,			__a ):
	return translate_message(__a ,			__a ,			'decrypt' )


def 				SCREAMING_SNAKE_CASE__    (     ):
	snake_case_		:      Optional[int]           =						'Hello World'
	snake_case_		:      Dict           =						'QWERTYUIOPASDFGHJKLZXCVBNM'
	snake_case_		:      Optional[Any]           =						'decrypt'  # set to 'encrypt' or 'decrypt'

	if mode == "encrypt":
		snake_case_		:      List[str]           =						encrypt_message(__a ,			__a )
	elif mode == "decrypt":
		snake_case_		:      Optional[Any]           =						decrypt_message(__a ,			__a )
	print(f"""Using the key {key}, the {mode}ed message is: {translated}""" )


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						main()







import math
from itertools import permutations


def 				__SCREAMING_SNAKE_CASE    (     snake_case_		):

						'''simple docstring'''


						if 1 < number < 4:
												# 2 and 3 are primes
												return True
						elif number < 2 or number % 2 == 0 or number % 3 == 0:
												# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
												return False

						# All primes number are in format of 6k +/- 1
						for i in range(5      ,       int(math.sqrt(snake_case_		) + 1		)      ,       6		):
												if number % i == 0 or number % (i + 2) == 0:
																		return False
						return True


def 				__SCREAMING_SNAKE_CASE    (     snake_case_      ,       snake_case_		):

						'''simple docstring'''


						_UpperCAmelCase				,					_UpperCAmelCase						=	0, len(snake_case_		) - 1
						while left <= right:
												_UpperCAmelCase						=	(left + right) // 2
												if prime_list[middle] == target:
																		return True
												elif prime_list[middle] < target:
																		_UpperCAmelCase						=	middle + 1
												else:
																		_UpperCAmelCase						=	middle - 1

						return False


def 				__SCREAMING_SNAKE_CASE    (     ):

						'''simple docstring'''


						_UpperCAmelCase						=	[n for n in range(1001      ,       1_0000      ,       2		) if is_prime(snake_case_		)]
						_UpperCAmelCase						=	[]

						for number in prime_list:
												_UpperCAmelCase						=	[]

												for prime_member in permutations(list(str(snake_case_		)		)		):
																		_UpperCAmelCase						=	int("".join(snake_case_		)		)

																		if prime % 2 == 0:
																								continue

																		if search(snake_case_      ,       snake_case_		):
																								tmp_numbers.append(snake_case_		)

												tmp_numbers.sort()
												if len(snake_case_		) >= 3:
																		candidates.append(snake_case_		)

						_UpperCAmelCase						=	[]
						for candidate in candidates:
												_UpperCAmelCase						=	len(snake_case_		)
												_UpperCAmelCase						=	False

												for i in range(snake_case_		):
																		for j in range(i + 1      ,       snake_case_		):
																								for k in range(j + 1      ,       snake_case_		):
																														if (
																														    abs(candidate[i] - candidate[j]		)
																														    == abs(candidate[j] - candidate[k]		)
																														    and len({candidate[i], candidate[j], candidate[k]}		) == 3
																														):
																																				passed.append(
																																				    sorted([candidate[i], candidate[j], candidate[k]]		)		)
																																				_UpperCAmelCase						=	True

																														if found:
																																				break
																								if found:
																														break
																		if found:
																								break

						_UpperCAmelCase						=	set()
						for seq in passed:
												answer.add("".join([str(snake_case_		) for i in seq]		)		)

						return max(int(snake_case_		) for x in answer		)


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




