"""simple docstring"""


def 					UpperCAmelCase    (		UpperCAmelCase						,					UpperCAmelCase					)				->      str:

     if not (isinstance(UpperCAmelCase						,					UpperCAmelCase					) and isinstance(UpperCAmelCase						,					UpperCAmelCase					)):
          raise ValueError('longest_common_substring() takes two strings for inputs'					)

     snake_case_					       =					len(UpperCAmelCase					)
     snake_case_					       =					len(UpperCAmelCase					)

     snake_case_					       =					[[0] * (texta_length + 1) for _ in range(texta_length + 1					)]
     snake_case_					       =					0
     snake_case_					       =					0

     for i in range(1						,					texta_length + 1					):
          for j in range(1						,					texta_length + 1					):
               if texta[i - 1] == texta[j - 1]:
                    snake_case_					       =					1 + dp[i - 1][j - 1]
                    if dp[i][j] > ans_length:
                         snake_case_					       =					i
                         snake_case_					       =					dp[i][j]

     return texta[ans_index - ans_length : ans_index]


if __name__ == "__main__":
    import doctest

    doctest.testmod()







"""simple docstring"""




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

import torch_xla.distributed.xla_multiprocessing as xmp



def     a__ (				)						->					Union[str, Any]:
			lowerCamelCase			      =					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=snake_case__       , default=1       , help="""Number of TPU cores to use (1 or 8)."""				)

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

			return parser.parse_args()



def     a__ (				)						->					List[str]:
			lowerCamelCase			      =					parse_args()

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

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



