


'''simple docstring'''





from __future__ import annotations





def   _UpperCAmelCase       (     UpperCAmelCase      :			Optional[Any]						,	UpperCAmelCase      :			List[str] = None						,	UpperCAmelCase      :			Union[str, Any] = None						,	UpperCAmelCase      :			Optional[int] = False						,	):
      """simple docstring"""




      __lowerCamelCase     :      Union[str, Any]       						=						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)
            __lowerCamelCase     :      List[Any]       						=						{
                """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     :      Union[str, Any]       						=						frequencies_dict

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

      # Chi squared statistic values
      __lowerCamelCase     :      Tuple       						=						{}

      # cycle through all of the shifts
      for shift in range(len(UpperCAmelCase__      )      ):
            __lowerCamelCase     :      str       						=						""""""

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

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

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

                              # Complete the chi squared statistic formula
                              __lowerCamelCase     :      Optional[int]       						=						((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     :      Any       						=						decrypted_with_shift.count(UpperCAmelCase__      )

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

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

      __lowerCamelCase     :      List[str]       						=						min(
          UpperCAmelCase__						,	key=UpperCAmelCase__						,	)

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







def   _UpperCAmelCase       (     UpperCAmelCase      :			str      ):
      """simple docstring"""




      __lowerCamelCase     :      List[Any]       						=						hex_num.strip()
      if not hex_num:
            raise ValueError("""No value was passed to the function"""      )

      __lowerCamelCase     :      Dict       						=						hex_num[0] == """-"""
      if is_negative:
            __lowerCamelCase     :      Optional[Any]       						=						hex_num[1:]

      try:
            __lowerCamelCase     :      Any       						=						int(UpperCAmelCase						,	16      )
      except ValueError:
            raise ValueError("""Invalid value was passed to the function"""      )

      __lowerCamelCase     :      List[str]       						=						""""""
      while int_num > 0:
            __lowerCamelCase     :      Dict       						=						str(int_num % 2      ) + bin_str
            int_num >>= 1

      return int(("""-""" + bin_str) if is_negative else bin_str      )


if __name__ == "__main__":
    import doctest

    doctest.testmod()



