

'''simple docstring'''
lowerCamelCase :      Tuple					 =     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"


def        _lowerCAmelCase					(						)      ->			None:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							    =input('Enter message: '				)
     _SCREAMING_SNAKE_CASE							    =input('Enter key [alphanumeric]: '				)
     _SCREAMING_SNAKE_CASE							    =input('Encrypt/Decrypt [e/d]: '				)

     if mode.lower().startswith('e'				):
          _SCREAMING_SNAKE_CASE							    ='encrypt'
          _SCREAMING_SNAKE_CASE							    =encrypt_message(_UpperCamelCase							, _UpperCamelCase				)
     elif mode.lower().startswith('d'				):
          _SCREAMING_SNAKE_CASE							    ='decrypt'
          _SCREAMING_SNAKE_CASE							    =decrypt_message(_UpperCamelCase							, _UpperCamelCase				)

     print(f"\n{mode.title()}ed message:"				)
     print(_UpperCamelCase				)


def        _lowerCAmelCase					(						_UpperCamelCase						:     str							, _UpperCamelCase						:     str				)      ->			str:
     """simple docstring"""




     return translate_message(_UpperCamelCase							, _UpperCamelCase							, 'encrypt'				)


def        _lowerCAmelCase					(						_UpperCamelCase						:     str							, _UpperCamelCase						:     str				)      ->			str:
     """simple docstring"""




     return translate_message(_UpperCamelCase							, _UpperCamelCase							, 'decrypt'				)


def        _lowerCAmelCase					(						_UpperCamelCase						:     str							, _UpperCamelCase						:     str							, _UpperCamelCase						:     str				)      ->			str:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							    =[]
     _SCREAMING_SNAKE_CASE							    =0
     _SCREAMING_SNAKE_CASE							    =key.upper()

     for symbol in message:
          _SCREAMING_SNAKE_CASE							    =LETTERS.find(symbol.upper()				)
          if num != -1:
               if mode == "encrypt":
                    num += LETTERS.find(key[key_index]				)
               elif mode == "decrypt":
                    num -= LETTERS.find(key[key_index]				)

               num %= len(_UpperCamelCase				)

               if symbol.isupper():
                    translated.append(LETTERS[num]				)
               elif symbol.islower():
                    translated.append(LETTERS[num].lower()				)

               key_index += 1
               if key_index == len(_UpperCamelCase				):
                    _SCREAMING_SNAKE_CASE							    =0
          else:
               translated.append(_UpperCamelCase				)
     return "".join(_UpperCamelCase				)


if __name__ == "__main__":
     main()



'''simple docstring'''
import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp


def        _lowerCAmelCase					(						)      ->			Any:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							    =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        _lowerCAmelCase					(						)      ->			Optional[int]:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							    =parse_args()

     # Import training_script as a module.
     _SCREAMING_SNAKE_CASE							    =Path(args.training_script				)
     sys.path.append(str(script_fpath.parent.resolve()				)				)
     _SCREAMING_SNAKE_CASE							    =script_fpath.stem
     _SCREAMING_SNAKE_CASE							    =importlib.import_module(_UpperCamelCase				)

     # Patch sys.argv
     _SCREAMING_SNAKE_CASE							    =[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()
