






from collections import defaultdict






def    __magic_name__    (	SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE				)     ->    bool:
							_lowercase							:   Union[str, Any] 							=   first_str.lower().strip()
							_lowercase							:   Tuple 							=   second_str.lower().strip()

							# Remove whitespace
							_lowercase							:   Dict 							=   first_str.replace(' '     ,     ''				)
							_lowercase							:   str 							=   second_str.replace(' '     ,     ''				)

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

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

							# For each character in input strings,
							# increment count in the corresponding
							for i in range(len(SCREAMING_SNAKE_CASE				)				):
														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'''
import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp


def       _lowercase							(					):
 __A	:		List[Any]	  =      ArgumentParser(
     description=(
         'PyTorch TPU distributed training launch helper utility that will spawn up multiple distributed processes'
     )      )

 # Optional arguments for the launch helper
 parser.add_argument('--num_cores',					type=UpperCamelCase__,					default=1,					help='Number of TPU cores to use (1 or 8).'      )

 # positional
 parser.add_argument(
     'training_script',					type=UpperCamelCase__,					help=(
         'The full path to the single TPU training '
         'program/script to be launched in parallel, '
         'followed by all the arguments for the '
         'training script'
     ),					)

 # rest from the training program
 parser.add_argument('training_script_args',					nargs=UpperCamelCase__      )

 return parser.parse_args()


def       _lowercase							(					):
 __A	:		str	  =      parse_args()

 # Import training_script as a module.
 __A	:		Tuple	  =      Path(args.training_script      )
 sys.path.append(str(script_fpath.parent.resolve()      )      )
 __A	:		str	  =      script_fpath.stem
 __A	:		Dict	  =      importlib.import_module(UpperCamelCase__      )

 # Patch sys.argv
 __A	:		Optional[Any]	  =      [args.training_script] + args.training_script_args + ['--tpu_num_cores', str(args.num_cores      )]

 xmp.spawn(mod._mp_fn,					args=(),					nprocs=args.num_cores      )


if __name__ == "__main__":
 main()






