





__lowerCamelCase :  Tuple										=  {
    """A""": """.-""", """B""": """-...""", """C""": """-.-.""", """D""": """-..""", """E""": """.""", """F""": """..-.""", """G""": """--.""",
    """H""": """....""", """I""": """..""", """J""": """.---""", """K""": """-.-""", """L""": """.-..""", """M""": """--""", """N""": """-.""",
    """O""": """---""", """P""": """.--.""", """Q""": """--.-""", """R""": """.-.""", """S""": """...""", """T""": """-""", """U""": """..-""",
    """V""": """...-""", """W""": """.--""", """X""": """-..-""", """Y""": """-.--""", """Z""": """--..""", """1""": """.----""",
    """2""": """..---""", """3""": """...--""", """4""": """....-""", """5""": """.....""", """6""": """-....""", """7""": """--...""",
    """8""": """---..""", """9""": """----.""", """0""": """-----""", """&""": """.-...""", """@""": """.--.-.""",
    """:""": """---...""", """,""": """--..--""", """.""": """.-.-.-""", """'""": """.----.""", """\"""": """.-..-.""",
    """?""": """..--..""", """/""": """-..-.""", """=""": """-...-""", """+""": """.-.-.""", """-""": """-....-""",
    """(""": """-.--.""", """)""": """-.--.-""", """!""": """-.-.--""", """ """: """/"""
}  # Exclamation mark is not in ITU-R recommendation
# fmt: on
__lowerCamelCase :  str										=  {value: key for key, value in MORSE_CODE_DICT.items()}



def 	A_       (  _lowerCAmelCase  )		->				str:
 return " ".join(MORSE_CODE_DICT[char] for char in message.upper()  )



def 	A_       (  _lowerCAmelCase  )		->				str:
 return "".join(REVERSE_DICT[char] for char in message.split()  )



def 	A_       (  )		->				None:
 UpperCamelCase			:      Union[str, Any] 			=     "Morse code here!"
 print(_SCREAMING_SNAKE_CASE  )
 UpperCamelCase			:      Optional[int] 			=     encrypt(_SCREAMING_SNAKE_CASE  )
 print(_SCREAMING_SNAKE_CASE  )
 UpperCamelCase			:      str 			=     decrypt(_SCREAMING_SNAKE_CASE  )
 print(_SCREAMING_SNAKE_CASE  )


if __name__ == "__main__":
    main()







import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp



def 	A_       (  )		->				Dict:
 UpperCamelCase			:      Tuple 			=     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=_lowerCAmelCase							,     default=1							,     help="Number of TPU cores to use (1 or 8)."  )

 # positional
 parser.add_argument(
     "training_script"							,     type=_lowerCAmelCase							,     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=_lowerCAmelCase  )

 return parser.parse_args()



def 	A_       (  )		->				Optional[int]:
 UpperCamelCase			:      Tuple 			=     parse_args()

 # Import training_script as a module.
 UpperCamelCase			:      Union[str, Any] 			=     Path(args.training_script  )
 sys.path.append(str(script_fpath.parent.resolve()  )  )
 UpperCamelCase			:      List[Any] 			=     script_fpath.stem
 UpperCamelCase			:      Optional[Any] 			=     importlib.import_module(_lowerCAmelCase  )

 # Patch sys.argv
 UpperCamelCase			:      List[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()
