'''simple docstring'''




from __future__ import annotations






def __lowerCAmelCase (							UpperCamelCase__				,  UpperCamelCase__ = None				,  UpperCamelCase__ = None				,  UpperCamelCase__ = False				,  )	->    tuple[int, float, str]:
    __lowerCamelCase		=  cipher_alphabet or [chr(UpperCamelCase__				) for i in range(97				,  1_23				)]

    # 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)
        __lowerCamelCase		=  {
            '''a''': 0.0_8_4_9_7,
            '''b''': 0.0_1_4_9_2,
            '''c''': 0.0_2_2_0_2,
            '''d''': 0.0_4_2_5_3,
            '''e''': 0.1_1_1_6_2,
            '''f''': 0.0_2_2_2_8,
            '''g''': 0.0_2_0_1_5,
            '''h''': 0.0_6_0_9_4,
            '''i''': 0.0_7_5_4_6,
            '''j''': 0.0_0_1_5_3,
            '''k''': 0.0_1_2_9_2,
            '''l''': 0.0_4_0_2_5,
            '''m''': 0.0_2_4_0_6,
            '''n''': 0.0_6_7_4_9,
            '''o''': 0.0_7_5_0_7,
            '''p''': 0.0_1_9_2_9,
            '''q''': 0.0_0_0_9_5,
            '''r''': 0.0_7_5_8_7,
            '''s''': 0.0_6_3_2_7,
            '''t''': 0.0_9_3_5_6,
            '''u''': 0.0_2_7_5_8,
            '''v''': 0.0_0_9_7_8,
            '''w''': 0.0_2_5_6_0,
            '''x''': 0.0_0_1_5_0,
            '''y''': 0.0_1_9_9_4,
            '''z''': 0.0_0_0_7_7,
        }
    else:
        # Custom frequencies dictionary
        __lowerCamelCase		=  frequencies_dict

    if not case_sensitive:
        __lowerCamelCase		=  ciphertext.lower()

    # Chi squared statistic values
    __lowerCamelCase		=  {}

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

        # decrypt the message with the shift
        for letter in ciphertext:
            try:
                # Try to index the letter in the alphabet
                __lowerCamelCase		=  (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

        __lowerCamelCase		=  0.0

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

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

                    # Complete the chi squared statistic formula
                    __lowerCamelCase		=  ((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
                    __lowerCamelCase		=  decrypted_with_shift.count(UpperCamelCase__				)

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

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

    __lowerCamelCase		=  min(
        UpperCamelCase__				,  key=UpperCamelCase__				,  )

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


     '''simple docstring'''




     return x if y == 0 else greatest_common_divisor(snake_case_					,    x % y			)





def 	lowerCAmelCase_				(					snake_case_       : int					,    snake_case_       : int			)    ->      int:


     '''simple docstring'''




     return (x * y) // greatest_common_divisor(snake_case_					,    snake_case_			)





def 	lowerCAmelCase_				(					snake_case_       : int = 20			)    ->      int:


     '''simple docstring'''




     UpperCAmelCase_           =   1
     for i in range(1					,    n + 1			):
          UpperCAmelCase_           =   lcm(snake_case_					,    snake_case_			)
     return g


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




