

from collections import defaultdict







def 		_lowercase (     lowercase__   ,	lowercase__						):
      __lowerCAmelCase					:						Tuple					=					first_str.lower().strip()
      __lowerCAmelCase					:						List[Any]					=					second_str.lower().strip()

      # Remove whitespace
      __lowerCAmelCase					:						Dict					=					first_str.replace(''' '''   ,	''''''						)
      __lowerCAmelCase					:						Tuple					=					second_str.replace(''' '''   ,	''''''						)

      # Strings of different lengths are not anagrams
      if len(UpperCAmelCase__						) != len(UpperCAmelCase__						):
            return False

      # Default values for count should be 0
      __lowerCAmelCase					:						defaultdict[str, int]					=					defaultdict(UpperCAmelCase__						)

      # For each character in input strings,
      # increment count in the corresponding
      for i in range(len(UpperCAmelCase__						)						):
            count[first_str[i]] += 1
            count[second_str[i]] -= 1

      return all(_count == 0 for _count in count.values()						)


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

 testmod()
 _UpperCamelCase 			=		input("Enter the first string ").strip()
 _UpperCamelCase 			=		input("Enter the second string ").strip()

 _UpperCamelCase 			=		check_anagrams(input_a, input_b)
 print(F"{input_a} and {input_b} are {'' if status else 'not '}anagrams.")



'''simple docstring'''




from itertools import product




def 							lowerCamelCase	(      UpperCAmelCase__       :					int      ,      UpperCAmelCase__       :					int )			->      list[int]:
							lowercase_					:			List[Any]										=       sides_number
							lowercase_					:			Dict										=       max_face_number * dice_number
							lowercase_					:			List[str]										=       [0] * (max_total + 1)

							lowercase_					:			Union[str, Any]										=       1
							lowercase_					:			Dict										=       range(UpperCAmelCase__      ,      max_face_number + 1 )
							for dice_numbers in product(UpperCAmelCase__      ,      repeat=UpperCAmelCase__ ):
														lowercase_					:			Any										=       sum(UpperCAmelCase__ )
														totals_frequencies[total] += 1

							return totals_frequencies




def 							lowerCamelCase	(      )			->      float:
							lowercase_					:			Optional[Any]										=       total_frequency_distribution(
							    sides_number=4      ,      dice_number=9 )
							lowercase_					:			List[str]										=       total_frequency_distribution(
							    sides_number=6      ,      dice_number=6 )

							lowercase_					:			Union[str, Any]										=       0
							lowercase_					:			Tuple										=       9
							lowercase_					:			Optional[int]										=       4 * 9
							lowercase_					:			List[Any]										=       6
							for peter_total in range(UpperCAmelCase__      ,      max_peter_total + 1 ):
														peter_wins_count += peter_totals_frequencies[peter_total] * sum(
														    colin_totals_frequencies[min_colin_total:peter_total] )

							lowercase_					:			str										=       (4**9) * (6**6)
							lowercase_					:			List[Any]										=       peter_wins_count / total_games_number

							lowercase_					:			Dict										=       round(UpperCAmelCase__      ,      ndigits=7 )

							return rounded_peter_win_probability


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





