import string

# frequency taken from https://en.wikipedia.org/wiki/Letter_frequency
_UpperCAmelCase :			Tuple              =	{
    "E": 12.70,
    "T": 9.06,
    "A": 8.17,
    "O": 7.51,
    "I": 6.97,
    "N": 6.75,
    "S": 6.33,
    "H": 6.09,
    "R": 5.99,
    "D": 4.25,
    "L": 4.03,
    "C": 2.78,
    "U": 2.76,
    "M": 2.41,
    "W": 2.36,
    "F": 2.23,
    "G": 2.02,
    "Y": 1.97,
    "P": 1.93,
    "B": 1.29,
    "V": 0.98,
    "K": 0.77,
    "J": 0.15,
    "X": 0.15,
    "Q": 0.10,
    "Z": 0.07,
}
_UpperCAmelCase :			Optional[Any]              =	"ETAOINSHRDLCUMWFGYPBVKJXQZ"
_UpperCAmelCase :			List[str]              =	"ABCDEFGHIJKLMNOPQRSTUVWXYZ"


def 				A	( lowercase			)       ->  dict[str, int]:
		'''simple docstring'''

		UpperCamelCase          =					{letter: 0 for letter in string.ascii_uppercase}
		for letter in message.upper():
				if letter in LETTERS:
						letter_count[letter] += 1

		return letter_count


def 				A	( lowercase			)       ->  str:
		'''simple docstring'''

		return x[0]


def 				A	( lowercase			)       ->  str:
		'''simple docstring'''

		UpperCamelCase          =					get_letter_count(__lowerCamelCase			)
		UpperCamelCase          =					{
		    freq: [] for letter, freq in letter_to_freq.items()
		}
		for letter in LETTERS:
				freq_to_letter[letter_to_freq[letter]].append(__lowerCamelCase			)

		UpperCamelCase          =					{}

		for freq in freq_to_letter:
				freq_to_letter[freq].sort(key=ETAOIN.find   ,	reverse=__lowerCamelCase			)
				UpperCamelCase          =					''.join(freq_to_letter[freq]			)

		UpperCamelCase          =					list(freq_to_letter_str.items()			)
		freq_pairs.sort(key=__lowerCamelCase   ,	reverse=__lowerCamelCase			)

		UpperCamelCase          =					[freq_pair[1] for freq_pair in freq_pairs]

		return "".join(__lowerCamelCase			)


def 				A	( lowercase			)       ->  int:
		'''simple docstring'''

		UpperCamelCase          =					get_frequency_order(__lowerCamelCase			)
		UpperCamelCase          =					0
		for common_letter in ETAOIN[:6]:
				if common_letter in freq_order[:6]:
						match_score += 1

		for uncommon_letter in ETAOIN[-6:]:
				if uncommon_letter in freq_order[-6:]:
						match_score += 1

		return match_score


if __name__ == "__main__":
					import doctest

					doctest.testmod()


from __future__ import annotations


def 				A	( lowercase   ,	lowercase			)       ->  tuple[int, int]:
		'''simple docstring'''

		if b == 0:
				return (1, 0)
		((UpperCamelCase)     ,  (UpperCamelCase))          =					extended_euclid(lowercase   ,	a % b			)
		UpperCamelCase          =					a // b
		return (y, x - k * y)


def 				A	( lowercase   ,	lowercase   ,	lowercase   ,	lowercase			)       ->  int:
		'''simple docstring'''

		((UpperCamelCase)     ,  (UpperCamelCase))          =					extended_euclid(lowercase   ,	lowercase			)
		UpperCamelCase          =					na * na
		UpperCamelCase          =					ra * x * na + ra * y * na
		return (n % m + m) % m


def 				A	( lowercase   ,	lowercase			)       ->  int:
		'''simple docstring'''

		((UpperCamelCase)     ,  (UpperCamelCase))          =					extended_euclid(lowercase   ,	lowercase			)
		if b < 0:
				UpperCamelCase          =					(b % n + n) % n
		return b


def 				A	( lowercase   ,	lowercase   ,	lowercase   ,	lowercase			)       ->  int:
		'''simple docstring'''

		UpperCamelCase     ,  UpperCamelCase          =					invert_modulo(lowercase   ,	lowercase			), invert_modulo(lowercase   ,	lowercase			)
		UpperCamelCase          =					na * na
		UpperCamelCase          =					ra * x * na + ra * y * na
		return (n % m + m) % m


if __name__ == "__main__":
					from doctest import testmod

					testmod(name="chinese_remainder_theorem", verbose=True)
					testmod(name="chinese_remainder_theorem2", verbose=True)
					testmod(name="invert_modulo", verbose=True)
					testmod(name="extended_euclid", verbose=True)
