





"""simple docstring"""






from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase

def       __A (     a_  :str)						->						None:
				__a    ,  __a	:  Union[str, Any]         =					analyze_text(a_)
				__a	:  List[str]         =					list(''' ''' + ascii_lowercase)
				# what is our total sum of probabilities.
				__a	:  Any         =					sum(single_char_strings.values())

				# one length string
				__a	:  int         =					0
				# for each alpha we go in our dict and if it is in it we calculate entropy
				for ch in my_alphas:
								if ch in single_char_strings:
												__a	:  Dict         =					single_char_strings[ch]
												__a	:  List[str]         =					my_str / all_sum
												my_fir_sum += prob * math.loga(a_)  # entropy formula.

    # print entropy
				print(F"""{round(-1 * my_fir_sum):.1f}""")

				# two len string
				__a	:  int         =					sum(two_char_strings.values())
				__a	:  Tuple         =					0
				# for each alpha (two in size) calculate entropy.
				for cha in my_alphas:
								for cha in my_alphas:
												__a	:  Any         =					cha + cha
												if sequence in two_char_strings:
																__a	:  str         =					two_char_strings[sequence]
																__a	:  Dict         =					int(a_) / all_sum
																my_sec_sum += prob * math.loga(a_)

    # print second entropy
				print(F"""{round(-1 * my_sec_sum):.1f}""")

				# print the difference between them
				print(F"""{round((-1 * my_sec_sum) - (-1 * my_fir_sum)):.1f}""")

def       __A (     a_  :str)						->						tuple[dict, dict]:
				__a	:  Union[str, Any]         =					Counter()  # type: ignore
				__a	:  Any         =					Counter()  # type: ignore
				single_char_strings[text[-1]] += 1

				# first case when we have space at start.
				two_char_strings[" " + text[0]] += 1
				for i in range(0				,    len(a_) - 1):
								single_char_strings[text[i]] += 1
								two_char_strings[text[i : i + 2]] += 1
				return single_char_strings, two_char_strings

def       __A (     )						->						Dict:
				import doctest

				doctest.testmod()
				# text = (
				#     "Had repulsive dashwoods suspicion sincerity but advantage now him. Remark "
				#     "easily garret nor nay. Civil those mrs enjoy shy fat merry. You greatest "
				#     "jointure saw horrible. He private he on be imagine suppose. Fertile "
				#     "beloved evident through no service elderly is. Blind there if every no so "
				#     "at. Own neglected you preferred way sincerity delivered his attempted. To "
				#     "of message cottage windows do besides against uncivil.  Delightful "
				#     "unreserved impossible few estimating men favourable see entreaties. She "
				#     "propriety immediate was improving. He or entrance humoured likewise "
				#     "moderate. Much nor game son say feel. Fat make met can must form into "
				#     "gate. Me we offending prevailed discovery. "
				# )

				# calculate_prob(text)


if __name__ == "__main__":
		main()






"""simple docstring"""






def       __A (     a_  :int = 1_00_00_00)						->						int:
				__a	:  Tuple         =					[i - 1 for i in range(limit + 1)]

				for i in range(2				,    limit + 1):
								if phi[i] == i - 1:
												for j in range(2 * i				,    limit + 1				,    a_):
																phi[j] -= phi[j] // i

				return sum(phi[2 : limit + 1])


if __name__ == "__main__":
		print(solution())