

from __future__ import annotations






def        UpperCamelCase_(							_snake_case   :  str       ,     _snake_case   :  list[str] | None = None       ,     _snake_case   :  dict[str, float] | None = None       ,     _snake_case   :  bool = False       ,     ):




			"""simple docstring"""






			__a        =cipher_alphabet or [chr(UpperCamelCase__	) for i in range(97       ,     123	)]

			# If the argument is None or the user provided an empty dictionary
			if not frequencies_dict:
						# Frequencies of letters in the english language (how much they show up)
						__a        ={
						    'a': 0.08_497,
						    'b': 0.01_492,
						    'c': 0.02_202,
						    'd': 0.04_253,
						    'e': 0.11_162,
						    'f': 0.02_228,
						    'g': 0.02_015,
						    'h': 0.06_094,
						    'i': 0.07_546,
						    'j': 0.00_153,
						    'k': 0.01_292,
						    'l': 0.04_025,
						    'm': 0.02_406,
						    'n': 0.06_749,
						    'o': 0.07_507,
						    'p': 0.01_929,
						    'q': 0.00_095,
						    'r': 0.07_587,
						    's': 0.06_327,
						    't': 0.09_356,
						    'u': 0.02_758,
						    'v': 0.00_978,
						    'w': 0.02_560,
						    'x': 0.00_150,
						    'y': 0.01_994,
						    'z': 0.00_077,
						}
			else:
						# Custom frequencies dictionary
						__a        =frequencies_dict

			if not case_sensitive:
						__a        =ciphertext.lower()

			# Chi squared statistic values
			__a        ={}

			# cycle through all of the shifts
			for shift in range(len(UpperCamelCase__	)	):
						__a        =''

						# decrypt the message with the shift
						for letter in ciphertext:
									try:
												# Try to index the letter in the alphabet
												__a        =(alphabet_letters.index(letter.lower()	) - shift) % len(
												    UpperCamelCase__	)
												decrypted_with_shift += (
												    alphabet_letters[new_key].upper()
												    if case_sensitive and letter.isupper()
												    else alphabet_letters[new_key]
												)
									except ValueError:
												# Append the character if it isn't in the alphabet
												decrypted_with_shift += letter

						__a        =0.0

						# Loop through each letter in the decoded message with the shift
						for letter in decrypted_with_shift:
									if case_sensitive:
												__a        =letter.lower()
												if letter in frequencies:
															# Get the amount of times the letter occurs in the message
															__a        =decrypted_with_shift.lower().count(UpperCamelCase__	)

															# Get the excepcted amount of times the letter should appear based
															# on letter frequencies
															__a        =frequencies[letter] * occurrences

															# Complete the chi squared statistic formula
															__a        =((occurrences - expected) ** 2) / expected

															# Add the margin of error to the total chi squared statistic
															chi_squared_statistic += chi_letter_value
									else:
												if letter.lower() in frequencies:
															# Get the amount of times the letter occurs in the message
															__a        =decrypted_with_shift.count(UpperCamelCase__	)

															# Get the excepcted amount of times the letter should appear based
															# on letter frequencies
															__a        =frequencies[letter] * occurrences

															# Complete the chi squared statistic formula
															__a        =((occurrences - expected) ** 2) / expected

															# Add the margin of error to the total chi squared statistic
															chi_squared_statistic += chi_letter_value

        # Add the data to the chi_squared_statistic_values dictionary
						__a        =(
						    chi_squared_statistic,
						    decrypted_with_shift,
						)

			# Get the most likely cipher by finding the cipher with the smallest chi squared
			# statistic
			def chi_squared_statistic_values_sorting_key(_snake_case   :  int	) -> tuple[float, str]:
						return chi_squared_statistic_values[key]

			__a        =min(
			    UpperCamelCase__       ,     key=UpperCamelCase__       ,     )

			# Get all the data from the most likely cipher (key, decoded message)
			(
			    (
			    __a						
			)      ,    (
			    __a						
			)      ,    						
			)        =chi_squared_statistic_values[most_likely_cipher]

			# Return the data on the most likely shift
			return (
			    most_likely_cipher,
			    most_likely_cipher_chi_squared_value,
			    decoded_most_likely_cipher,
			)












from math import sqrt







def 			lowerCamelCase_		(       UpperCamelCase__				:      int      )     ->       bool:





				"""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(sqrt(UpperCamelCase__      ) + 1      ) ,     6      ):
								if number % i == 0 or number % (i + 2) == 0:
												return False
				return True







def 			lowerCamelCase_		(       UpperCamelCase__				:      int = 1_0001      )     ->       int:





				"""simple docstring"""


				__lowerCamelCase		       =    0
				__lowerCamelCase		       =    1
				while count != nth and number < 3:
								number += 1
								if is_prime(UpperCamelCase__      ):
												count += 1
				while count != nth:
								number += 2
								if is_prime(UpperCamelCase__      ):
												count += 1
				return number


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


