






from __future__ import annotations

from queue import Queue





def 						__UpperCAmelCase      (					a_							,					a_):
							a ^= b
							b ^= a
							a ^= b
							return a, b





def 						__UpperCAmelCase      (					a_							,					a_):
							snake_case_           =							1
							while (1 << j) < max_node:
														for i in range(1							,					max_node + 1):
																					snake_case_           =							parent[j - 1][parent[j - 1][i]]
														j += 1
							return parent





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





def 						__UpperCAmelCase      (					a_							,					a_							,					a_							,					a_							,					a_ = 1							,					):
							snake_case_           =							0
							snake_case_           =							Queue(maxsize=a_)
							q.put(a_)
							while q.qsize() != 0:
														snake_case_           =							q.get()
														for v in graph[u]:
																					if level[v] == -1:
																												snake_case_           =							level[u] + 1
																												q.put(a_)
																												snake_case_           =							u
							return level, parent





def 						__UpperCAmelCase      (					):
							snake_case_           =							13
							# initializing with 0
							snake_case_           =							[[0 for _ in range(max_node + 10)] for _ in range(20)]
							# initializing with -1 which means every node is unvisited
							snake_case_           =							[-1 for _ in range(max_node + 10)]
							snake_case_           =							{
							    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: [],
							}
							snake_case_      ,		snake_case_           =							breadth_first_search(a_							,					a_							,					a_							,					a_							,					1)
							snake_case_           =							create_sparse(a_							,					a_)
							print('LCA of node 1 and 3 is: '							,					lowest_common_ancestor(1							,					3							,					a_							,					a_))
							print('LCA of node 5 and 6 is: '							,					lowest_common_ancestor(5							,					6							,					a_							,					a_))
							print('LCA of node 7 and 11 is: '							,					lowest_common_ancestor(7							,					11							,					a_							,					a_))
							print('LCA of node 6 and 7 is: '							,					lowest_common_ancestor(6							,					7							,					a_							,					a_))
							print('LCA of node 4 and 12 is: '							,					lowest_common_ancestor(4							,					12							,					a_							,					a_))
							print('LCA of node 8 and 8 is: '							,					lowest_common_ancestor(8							,					8							,					a_							,					a_))


if __name__ == "__main__":
	main()













def 						__UpperCAmelCase      (					a_):
							return 1 if input_a == 0 else 0





def 						__UpperCAmelCase      (					):
							assert not_gate(0) == 1
							assert not_gate(1) == 0


if __name__ == "__main__":
	print(not_gate(0))
	print(not_gate(1))





