


"""simple docstring"""







def      lowercase			(				A_  ,   A_  ,   A_  ,   A_       )->      bool:
  '''simple docstring'''







  if graph[path[curr_ind - 1]][next_ver] == 0:
    return False

  # 2. Validate that next vertex is not already in path
  return not any(vertex == next_ver for vertex in path       )


def      lowercase			(				A_  ,   A_  ,   A_       )->      bool:
  '''simple docstring'''







  if curr_ind == len(A_       ):
    # return whether path exists between current and starting vertices
    return graph[path[curr_ind - 1]][path[0]] == 1

  # Recursive Step
  for next_ver in range(0  ,   len(A_       )       ):
    if valid_connection(A_  ,   A_  ,   A_  ,   A_       ):
      # Insert current vertex  into path as next transition
      a						:		List[Any]      							=			next_ver
      # Validate created path
      if util_hamilton_cycle(A_  ,   A_  ,   curr_ind + 1       ):
        return True
      # Backtrack
      a						:		List[str]      							=			-1
  return False







def      lowercase			(				A_  ,   A_ = 0       )->      list[int]:
  '''simple docstring'''







  a						:		Dict      							=			[-1] * (len(A_       ) + 1)
  # initialize start and end of path with starting index
  a						:		Union[str, Any]      							=			start_index
  # evaluate and if we find answer return path either return empty array
  return path if util_hamilton_cycle(A_  ,   A_  ,   1       ) else []











from collections import defaultdict





def      __snake_case	(			_UpperCAmelCase   , _UpperCAmelCase				):
    __a						       =				first_str.lower().strip()
    __a						       =				second_str.lower().strip()

    # Remove whitespace
    __a						       =				first_str.replace(''' '''   , ''''''				)
    __a						       =				second_str.replace(''' '''   , ''''''				)

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

    # Default values for count should be 0
    __a						       =				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()
 __snake_case						:Any      		=     input('''Enter the first string ''').strip()
 __snake_case						:int      		=     input('''Enter the second string ''').strip()

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





