



"""simple docstring"""

from __future__ import annotations




def __lowercase			(							_a		,			_a = None		,			_a = None		,			_a = False		,			):
    snake_case_ :     List[Any]				=	cipher_alphabet or [chr(_SCREAMING_SNAKE_CASE    ) 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)
        snake_case_ :     List[Any]				=	{
            'a': 0.0_8497,
            'b': 0.0_1492,
            'c': 0.0_2202,
            'd': 0.0_4253,
            'e': 0.1_1162,
            'f': 0.0_2228,
            'g': 0.0_2015,
            'h': 0.0_6094,
            'i': 0.0_7546,
            'j': 0.0_0153,
            'k': 0.0_1292,
            'l': 0.0_4025,
            'm': 0.0_2406,
            'n': 0.0_6749,
            'o': 0.0_7507,
            'p': 0.0_1929,
            'q': 0.0_0095,
            'r': 0.0_7587,
            's': 0.0_6327,
            't': 0.0_9356,
            'u': 0.0_2758,
            'v': 0.0_0978,
            'w': 0.0_2560,
            'x': 0.0_0150,
            'y': 0.0_1994,
            'z': 0.0_0077,
        }
    else:
        # Custom frequencies dictionary
        snake_case_ :     Dict				=	frequencies_dict

    if not case_sensitive:
        snake_case_ :     Any				=	ciphertext.lower()

    # Chi squared statistic values
    snake_case_ :     dict[int, tuple[float, str]]				=	{}

    # cycle through all of the shifts
    for shift in range(len(_SCREAMING_SNAKE_CASE    )    ):
        snake_case_ :     Optional[Any]				=	''

        # decrypt the message with the shift
        for letter in ciphertext:
            try:
                # Try to index the letter in the alphabet
                snake_case_ :     Optional[Any]				=	(alphabet_letters.index(letter.lower()    ) - shift) % len(
                    _SCREAMING_SNAKE_CASE    )
                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

        snake_case_ :     Union[str, Any]				=	0.0

        # Loop through each letter in the decoded message with the shift
        for letter in decrypted_with_shift:
            if case_sensitive:
                snake_case_ :     int				=	letter.lower()
                if letter in frequencies:
                    # Get the amount of times the letter occurs in the message
                    snake_case_ :     Optional[Any]				=	decrypted_with_shift.lower().count(_SCREAMING_SNAKE_CASE    )

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

                    # Complete the chi squared statistic formula
                    snake_case_ :     Optional[Any]				=	((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
                    snake_case_ :     Union[str, Any]				=	decrypted_with_shift.count(_SCREAMING_SNAKE_CASE    )

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

                    # Complete the chi squared statistic formula
                    snake_case_ :     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
        snake_case_ :     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(_a    ) -> tuple[float, str]:
        return chi_squared_statistic_values[key]

    snake_case_ :     int				=	min(
        _SCREAMING_SNAKE_CASE		,			key=_SCREAMING_SNAKE_CASE		,			)

    # Get all the data from the most likely cipher (key, decoded message)
    (
        snake_case_    
    ) :     str				=	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,
    )






"""simple docstring"""
def 						__a   (	_SCREAMING_SNAKE_CASE = 1000000   )	->int:
  a__:     int										=	limit + 1
  a__:     Optional[int]										=	[0] * limit
  for first_term in range(1		,     _SCREAMING_SNAKE_CASE   ):
    for n in range(_SCREAMING_SNAKE_CASE		,     _SCREAMING_SNAKE_CASE		,     _SCREAMING_SNAKE_CASE   ):
      a__:     List[Any]										=	first_term + n / first_term
      if common_difference % 4:  # d must be divisble by 4
        continue
      else:
        common_difference /= 4
        if (
            first_term > common_difference
            and first_term < 4 * common_difference
        ):  # since x,y,z are positive integers
          frequency[n] += 1  # so z>0 and a>d ,also 4d<a

  a__:     Any										=	sum(1 for x in frequency[1:limit] if x == 10   )

  return count


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


