



from __future__ import annotations


def  __lowerCamelCase (       lowerCamelCase__					,			lowerCamelCase__ = None					,			lowerCamelCase__ = None					,			lowerCamelCase__ = False					,			):

				"""simple docstring"""


				lowercase__					:   Union[str, Any]													=					cipher_alphabet or [chr(_lowercase						) 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)
								lowercase__					:   Optional[int]													=					{
								    "a": 0.08497,
								    "b": 0.01492,
								    "c": 0.02202,
								    "d": 0.04253,
								    "e": 0.11162,
								    "f": 0.02228,
								    "g": 0.02015,
								    "h": 0.06094,
								    "i": 0.07546,
								    "j": 0.00153,
								    "k": 0.01292,
								    "l": 0.04025,
								    "m": 0.02406,
								    "n": 0.06749,
								    "o": 0.07507,
								    "p": 0.01929,
								    "q": 0.00095,
								    "r": 0.07587,
								    "s": 0.06327,
								    "t": 0.09356,
								    "u": 0.02758,
								    "v": 0.00978,
								    "w": 0.02560,
								    "x": 0.00150,
								    "y": 0.01994,
								    "z": 0.00077,
								}
				else:
								# Custom frequencies dictionary
								lowercase__					:   List[Any]													=					frequencies_dict

				if not case_sensitive:
								lowercase__					:   int													=					ciphertext.lower()

				# Chi squared statistic values
				lowercase__					:   List[Any]													=					{}

				# cycle through all of the shifts
				for shift in range(len(_lowercase						)						):
								lowercase__					:   List[str]													=					""

								# decrypt the message with the shift
								for letter in ciphertext:
												try:
																# Try to index the letter in the alphabet
																lowercase__					:   Dict													=					(alphabet_letters.index(letter.lower()						) - shift) % len(
																    _lowercase						)
																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

								lowercase__					:   Any													=					0.0

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

																				# Get the excepcted amount of times the letter should appear based
																				# on letter frequencies
																				lowercase__					:   Optional[Any]													=					frequencies[letter] * occurrences

																				# Complete the chi squared statistic formula
																				lowercase__					:   Dict													=					((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
																				lowercase__					:   List[Any]													=					decrypted_with_shift.count(_lowercase						)

																				# Get the excepcted amount of times the letter should appear based
																				# on letter frequencies
																				lowercase__					:   Optional[Any]													=					frequencies[letter] * occurrences

																				# Complete the chi squared statistic formula
																				lowercase__					:   Optional[int]													=					((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
								lowercase__					:   int													=					(
								    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(lowerCamelCase__						) -> tuple[float, str]:
								return chi_squared_statistic_values[key]

				lowercase__					:   Optional[Any]													=					min(
				    _lowercase					,			key=_lowercase					,			)

				# Get all the data from the most likely cipher (key, decoded message)
				(
				    (
				    lowercase__
				)							,							(
				    lowercase__
				)							,							
				)					:   Optional[int]													=					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 ceil, sqrt


def  __lowerCamelCase (       lowerCamelCase__ = 1_000_000						):

				"""simple docstring"""


				lowercase__					:   int													=					0

				for outer_width in range(3					,			(limit // 4) + 2						):
								if outer_width**2 > limit:
												lowercase__					:   List[str]													=					max(ceil(sqrt(outer_width**2 - limit						)						)					,			1						)
								else:
												lowercase__					:   List[str]													=					1
								if (outer_width - hole_width_lower_bound) % 2:
												hole_width_lower_bound += 1

								answer += (outer_width - hole_width_lower_bound - 2) // 2 + 1

				return answer


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




