

from __future__ import annotations

from queue import Queue

def 	lowerCamelCase__	(   _a							,     _a):
 a ^= b
 b ^= a
 a ^= b
 return a, b

def 	lowerCamelCase__	(   _a							,     _a):
 SCREAMING_SNAKE_CASE				: str			       =    1
 while (1 << j) < max_node:
  for i in range(1							,     max_node + 1):
   SCREAMING_SNAKE_CASE				: Any			       =    parent[j - 1][parent[j - 1][i]]
  j += 1
 return parent

def 	lowerCamelCase__	(   _a							,     _a							,     _a							,     _a):
 # u must be deeper in the tree than v
 if level[u] < level[v]:
  SCREAMING_SNAKE_CASE				: str			       =    swap(lowercase__							,     lowercase__)
 # making depth of u same as depth of v
 for i in range(18							,     -1							,     -1):
  if level[u] - (1 << i) >= level[v]:
   SCREAMING_SNAKE_CASE				: 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]]:
   SCREAMING_SNAKE_CASE				: List[Any]			       =    parent[i][u], parent[i][v]
    # returning longest common ancestor of u,v
 return parent[0][u]

def 	lowerCamelCase__	(   _a							,     _a							,     _a							,     _a							,     _a = 1							,     ):
 SCREAMING_SNAKE_CASE				: int			       =    0
 SCREAMING_SNAKE_CASE				: Queue[int]			       =    Queue(maxsize=lowercase__)
 q.put(lowercase__)
 while q.qsize() != 0:
  SCREAMING_SNAKE_CASE				: Any			       =    q.get()
  for v in graph[u]:
   if level[v] == -1:
    SCREAMING_SNAKE_CASE				: str			       =    level[u] + 1
    q.put(lowercase__)
    SCREAMING_SNAKE_CASE				: Any			       =    u
 return level, parent

def 	lowerCamelCase__	(   ):
 SCREAMING_SNAKE_CASE				: str			       =    13
 # initializing with 0
 SCREAMING_SNAKE_CASE				: Dict			       =    [[0 for _ in range(max_node + 10)] for _ in range(20)]
 # initializing with -1 which means every node is unvisited
 SCREAMING_SNAKE_CASE				: List[Any]			       =    [-1 for _ in range(max_node + 10)]
 SCREAMING_SNAKE_CASE				: 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: [],
 }
 SCREAMING_SNAKE_CASE				: List[Any]			       =    breadth_first_search(lowercase__							,     lowercase__							,     lowercase__							,     lowercase__							,     1)
 SCREAMING_SNAKE_CASE				: List[str]			       =    create_sparse(lowercase__							,     lowercase__)
 print("LCA of node 1 and 3 is: "							,     lowest_common_ancestor(1							,     3							,     lowercase__							,     lowercase__))
 print("LCA of node 5 and 6 is: "							,     lowest_common_ancestor(5							,     6							,     lowercase__							,     lowercase__))
 print("LCA of node 7 and 11 is: "							,     lowest_common_ancestor(7							,     11							,     lowercase__							,     lowercase__))
 print("LCA of node 6 and 7 is: "							,     lowest_common_ancestor(6							,     7							,     lowercase__							,     lowercase__))
 print("LCA of node 4 and 12 is: "							,     lowest_common_ancestor(4							,     12							,     lowercase__							,     lowercase__))
 print("LCA of node 8 and 8 is: "							,     lowest_common_ancestor(8							,     8							,     lowercase__							,     lowercase__))


if __name__ == "__main__":
   main()


from __future__ import annotations

from typing import Any






class _UpperCamelCase							:
			'''simple docstring'''







			def __init__(     self							:	Dict , a							:	Any , a							:	Any		)							->    None:  # noqa: A002

				"""simple docstring"""

				SCREAMING_SNAKE_CASE				: str			       =    item
				SCREAMING_SNAKE_CASE				: List[Any]			       =    next






class _UpperCamelCase							:
			'''simple docstring'''







			def __init__(     self							:	Optional[int]		)							->    None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE				: Node | None			       =    None
				SCREAMING_SNAKE_CASE				: List[Any]			       =    0
			def 							__UpperCamelCase	(     self							:	Union[str, Any] , a							:	Any		)							->    None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE				: Any			       =    Node(a , self.head		)
				self.size += 1
			def 							__UpperCamelCase	(     self							:	Dict		)							->    Any:

				"""simple docstring"""

				if self.head is None:
					return None
				else:
					SCREAMING_SNAKE_CASE				: Optional[int]			       =    self.head.item
					SCREAMING_SNAKE_CASE				: Dict			       =    self.head.next
					self.size -= 1
					return item
			def 							__UpperCamelCase	(     self							:	Any		)							->    bool:

				"""simple docstring"""

				return self.head is None
			def __str__(     self							:	Union[str, Any]		)							->    str:

				"""simple docstring"""

				if self.is_empty():
					return ""
				else:
					SCREAMING_SNAKE_CASE				: Union[str, Any]			       =    self.head
					SCREAMING_SNAKE_CASE				: str			       =    ""
					SCREAMING_SNAKE_CASE				: list[str]			       =    []
					while iterate:
						item_list.append(str(iterate.item		)		)
						SCREAMING_SNAKE_CASE				: str			       =    iterate.next

					SCREAMING_SNAKE_CASE				: List[str]			       =    " --> ".join(a		)

					return item_str






			def __len__(     self							:	List[Any]		)							->    int:

				"""simple docstring"""

				return self.size