"""simple docstring"""







from __future__ import annotations

from queue import Queue




def 						_lowercase				(  _SCREAMING_SNAKE_CASE				:				int  ,       _SCREAMING_SNAKE_CASE				:				int						)    ->     tuple[int, int]:







     '''simple docstring'''


     a ^= b
     b ^= a
     a ^= b
     return a, b




def 						_lowercase				(  _SCREAMING_SNAKE_CASE				:				int  ,       _SCREAMING_SNAKE_CASE				:				list[list[int]]						)    ->     list[list[int]]:







     '''simple docstring'''


     __A					:					List[str]								=		1
     while (1 << j) < max_node:
          for i in range(1  ,       max_node + 1						):
               __A					:					Tuple								=		parent[j - 1][parent[j - 1][i]]
          j += 1
     return parent




def 						_lowercase				(  _SCREAMING_SNAKE_CASE				:				int  ,       _SCREAMING_SNAKE_CASE				:				int  ,       _SCREAMING_SNAKE_CASE				:				list[int]  ,       _SCREAMING_SNAKE_CASE				:				list[list[int]]						)    ->     int:







     '''simple docstring'''


     if level[u] < level[v]:
          __A						,		__A					:					Optional[int]								=		swap(_SCREAMING_SNAKE_CASE  ,       _SCREAMING_SNAKE_CASE						)
     # making depth of u same as depth of v
     for i in range(18  ,       -1  ,       -1						):
          if level[u] - (1 << i) >= level[v]:
               __A					:					List[Any]								=		parent[i][u]
    # at the same depth if u==v that mean lca is found
     if u == v:
          return u
     # moving both nodes upwards till lca in found
     for i in range(18  ,       -1  ,       -1						):
          if parent[i][u] not in [0, parent[i][v]]:
               __A						,		__A					:					Any								=		parent[i][u], parent[i][v]
    # returning longest common ancestor of u,v
     return parent[0][u]




def 						_lowercase				(  _SCREAMING_SNAKE_CASE				:				list[int]  ,       _SCREAMING_SNAKE_CASE				:				list[list[int]]  ,       _SCREAMING_SNAKE_CASE				:				int  ,       _SCREAMING_SNAKE_CASE				:				dict[int, list[int]]  ,       _SCREAMING_SNAKE_CASE				:				int = 1  ,       )    ->     tuple[list[int], list[list[int]]]:







     '''simple docstring'''


     __A					:					Dict								=		0
     __A					:					Queue[int]								=		Queue(maxsize=_SCREAMING_SNAKE_CASE						)
     q.put(_SCREAMING_SNAKE_CASE						)
     while q.qsize() != 0:
          __A					:					List[str]								=		q.get()
          for v in graph[u]:
               if level[v] == -1:
                    __A					:					Optional[int]								=		level[u] + 1
                    q.put(_SCREAMING_SNAKE_CASE						)
                    __A					:					List[Any]								=		u
     return level, parent




def 						_lowercase				(  )    ->     None:







     '''simple docstring'''


     __A					:					Optional[Any]								=		13
     # initializing with 0
     __A					:					str								=		[[0 for _ in range(max_node + 10						)] for _ in range(20						)]
     # initializing with -1 which means every node is unvisited
     __A					:					Tuple								=		[-1 for _ in range(max_node + 10						)]
     __A					:					dict[int, list[int]]								=		{
         1: [2, 3, 4],
         2: [5],
         3: [6, 7],
         4: [8],
         5: [9, 10],
         6: [11],
         7: [],
         8: [12, 13],
         9: [],
         10: [],
         11: [],
         12: [],
         13: [],
     }
     __A						,		__A					:					Any								=		breadth_first_search(_SCREAMING_SNAKE_CASE  ,       _SCREAMING_SNAKE_CASE  ,       _SCREAMING_SNAKE_CASE  ,       _SCREAMING_SNAKE_CASE  ,       1						)
     __A					:					List[str]								=		create_sparse(_SCREAMING_SNAKE_CASE  ,       _SCREAMING_SNAKE_CASE						)
     print('LCA of node 1 and 3 is: '  ,       lowest_common_ancestor(1  ,       3  ,       _SCREAMING_SNAKE_CASE  ,       _SCREAMING_SNAKE_CASE						)						)
     print('LCA of node 5 and 6 is: '  ,       lowest_common_ancestor(5  ,       6  ,       _SCREAMING_SNAKE_CASE  ,       _SCREAMING_SNAKE_CASE						)						)
     print('LCA of node 7 and 11 is: '  ,       lowest_common_ancestor(7  ,       11  ,       _SCREAMING_SNAKE_CASE  ,       _SCREAMING_SNAKE_CASE						)						)
     print('LCA of node 6 and 7 is: '  ,       lowest_common_ancestor(6  ,       7  ,       _SCREAMING_SNAKE_CASE  ,       _SCREAMING_SNAKE_CASE						)						)
     print('LCA of node 4 and 12 is: '  ,       lowest_common_ancestor(4  ,       12  ,       _SCREAMING_SNAKE_CASE  ,       _SCREAMING_SNAKE_CASE						)						)
     print('LCA of node 8 and 8 is: '  ,       lowest_common_ancestor(8  ,       8  ,       _SCREAMING_SNAKE_CASE  ,       _SCREAMING_SNAKE_CASE						)						)


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 						_lowercase				(  )    ->     List[str]:







     '''simple docstring'''


     __A					:					int								=		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=_SCREAMING_SNAKE_CASE  ,       default=1  ,       help='Number of TPU cores to use (1 or 8).'						)

     # positional
     parser.add_argument(
         'training_script'  ,       type=_SCREAMING_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=_SCREAMING_SNAKE_CASE						)

     return parser.parse_args()




def 						_lowercase				(  )    ->     List[str]:







     '''simple docstring'''


     __A					:					List[str]								=		parse_args()

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

     # Patch sys.argv
     __A					:					Union[str, 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()



