
'''simple docstring'''





from __future__ import annotations

from queue import Queue





def 							snake_case				(		UpperCAmelCase   ,	UpperCAmelCase						)->      List[Any]:







      """simple docstring"""
      a ^= b
      b ^= a
      a ^= b
      return a, b





def 							snake_case				(		UpperCAmelCase   ,	UpperCAmelCase						)->      str:







      """simple docstring"""
      __A													=      1
      while (1 << j) < max_node:
            for i in range(1   ,	max_node + 1						):
                  __A													=      parent[j - 1][parent[j - 1][i]]
            j += 1
      return parent





def 							snake_case				(		UpperCAmelCase   ,	UpperCAmelCase   ,	UpperCAmelCase   ,	UpperCAmelCase						)->      Optional[int]:







      """simple docstring"""
      # u must be deeper in the tree than v
      if level[u] < level[v]:
            __A						,   __A													=      swap(SCREAMING_SNAKE_CASE_   ,	SCREAMING_SNAKE_CASE_						)
      # making depth of u same as depth of v
      for i in range(1_8   ,	-1   ,	-1						):
            if level[u] - (1 << i) >= level[v]:
                  __A													=      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(1_8   ,	-1   ,	-1						):
            if parent[i][u] not in [0, parent[i][v]]:
                  __A						,   __A													=      parent[i][u], parent[i][v]
    # returning longest common ancestor of u,v
      return parent[0][u]





def 							snake_case				(		UpperCAmelCase   ,	UpperCAmelCase   ,	UpperCAmelCase   ,	UpperCAmelCase   ,	UpperCAmelCase = 1   ,	)->      Dict:







      """simple docstring"""
      __A													=      0
      __A													=      Queue(maxsize=SCREAMING_SNAKE_CASE_						)
      q.put(SCREAMING_SNAKE_CASE_						)
      while q.qsize() != 0:
            __A													=      q.get()
            for v in graph[u]:
                  if level[v] == -1:
                        __A													=      level[u] + 1
                        q.put(SCREAMING_SNAKE_CASE_						)
                        __A													=      u
      return level, parent





def 							snake_case				(		)->      str:







      """simple docstring"""
      __A													=      1_3
      # initializing with 0
      __A													=      [[0 for _ in range(max_node + 1_0						)] for _ in range(2_0						)]
      # initializing with -1 which means every node is unvisited
      __A													=      [-1 for _ in range(max_node + 1_0						)]
      __A													=      {
          1: [2, 3, 4],
          2: [5],
          3: [6, 7],
          4: [8],
          5: [9, 1_0],
          6: [1_1],
          7: [],
          8: [1_2, 1_3],
          9: [],
          1_0: [],
          1_1: [],
          1_2: [],
          1_3: [],
      }
      __A						,   __A													=      breadth_first_search(SCREAMING_SNAKE_CASE_   ,	SCREAMING_SNAKE_CASE_   ,	SCREAMING_SNAKE_CASE_   ,	SCREAMING_SNAKE_CASE_   ,	1						)
      __A													=      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   ,	1_1   ,	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   ,	1_2   ,	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()












import json
import logging
import os
import subprocess
from argparse import ArgumentParser


UpperCamelCase__            =     logging.getLogger(__name__)







def       _a (		):
					__lowerCAmelCase							  =			ArgumentParser()
					__lowerCAmelCase  ,				__lowerCAmelCase							  =			parser.parse_known_args()
					for arg in unknown:
										if arg.startswith(("-", "--")	):
															parser.add_argument(arg.split("="	)[0]	)

					return parser.parse_args()







def       _a (		):
					__lowerCAmelCase							  =			parse_args()
					__lowerCAmelCase							  =			88_88
					__lowerCAmelCase							  =			int(os.environ["SM_NUM_GPUS"]	)
					__lowerCAmelCase							  =			json.loads(os.environ["SM_HOSTS"]	)
					__lowerCAmelCase							  =			len(SCREAMING_SNAKE_CASE_	)
					__lowerCAmelCase							  =			os.environ["SM_CURRENT_HOST"]
					__lowerCAmelCase							  =			hosts.index(SCREAMING_SNAKE_CASE_	)
					__lowerCAmelCase							  =			"INFO"

					if num_nodes > 1:
										__lowerCAmelCase							  =			F"""python -m torch.distributed.launch \
                --nnodes={num_nodes}  \
                --node_rank={rank}  \
                --nproc_per_node={num_gpus}  \
                --master_addr={hosts[0]}  \
                --master_port={port} \
                ./run_glue.py \
                {''.join(['nested fstring' for parameter,value in args.__dict__.items()]	)}"""
					else:
										__lowerCAmelCase							  =			F"""python -m torch.distributed.launch \
            --nproc_per_node={num_gpus}  \
            ./run_glue.py \
            {''.join(['nested fstring' for parameter,value in args.__dict__.items()]	)}"""
					try:
										subprocess.run(SCREAMING_SNAKE_CASE_ , shell=SCREAMING_SNAKE_CASE_	)
					except Exception as e:
										logger.info(SCREAMING_SNAKE_CASE_	)


if __name__ == "__main__":
					main()




