






from collections import defaultdict






def 						__magic_name__			(   __a      :	str	,		__a      :	str						):



     '''simple docstring'''




     UpperCamelCase__				=    first_str.lower().strip()
     UpperCamelCase__				=    second_str.lower().strip()

     # Remove whitespace
     UpperCamelCase__				=    first_str.replace(""" """	,		""""""						)
     UpperCamelCase__				=    second_str.replace(""" """	,		""""""						)

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

     # Default values for count should be 0
     UpperCamelCase__				=    defaultdict(__a						)

     # For each character in input strings,
     # increment count in the corresponding
     for i in range(len(__a						)						):
          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()
    lowerCamelCase_						     =					input('''Enter the first string ''').strip()
    lowerCamelCase_						     =					input('''Enter the second string ''').strip()

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







from __future__ import annotations

from collections import Counter
from random import random




class      __A:

  """simple docstring"""







  def __init__(self						):
       UpperCamelCase__				=    {}







  def 	UpperCAmelCase_ (self	,      SCREAMING_SNAKE_CASE_						):
       UpperCamelCase__				=    {}







  def 	UpperCAmelCase_ (self	,      SCREAMING_SNAKE_CASE_	,      SCREAMING_SNAKE_CASE_	,      SCREAMING_SNAKE_CASE_						):
       if nodea not in self.connections:
            self.add_node(SCREAMING_SNAKE_CASE_						)
       if nodea not in self.connections:
            self.add_node(SCREAMING_SNAKE_CASE_						)
       UpperCamelCase__				=    probability







  def 	UpperCAmelCase_ (self						):
       return list(self.connections						)







  def 	UpperCAmelCase_ (self	,      SCREAMING_SNAKE_CASE_						):
       UpperCamelCase__				=    0
       UpperCamelCase__				=    random()

       for dest in self.connections[node]:
            current_probability += self.connections[node][dest]
            if current_probability > random_value:
                 return dest
       return ""






def 						__magic_name__			(   __a      :	str	,		__a      :	list[tuple[str, str, float]]	,		__a      :	int						):



     '''simple docstring'''




     UpperCamelCase__				=    MarkovChainGraphUndirectedUnweighted()

     for nodea, nodea, probability in transitions:
          graph.add_transition_probability(__a	,		__a	,		__a						)

     UpperCamelCase__				=    Counter(graph.get_nodes()						)
     UpperCamelCase__				=    start

     for _ in range(__a						):
          UpperCamelCase__				=    graph.transition(__a						)
          visited[node] += 1

     return visited


if __name__ == "__main__":
    import doctest

    doctest.testmod()





