


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     					=1
				while (1 << j) < max_node:
								for i in range(1		,max_node + 1):
												_SCREAMING_SNAKE_CASE     					=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					,			_SCREAMING_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]:
												_SCREAMING_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]]:
												_SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE     					=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     					=0
				_SCREAMING_SNAKE_CASE     					=Queue(maxsize=a__)
				q.put(a__)
				while q.qsize() != 0:
								_SCREAMING_SNAKE_CASE     					=q.get()
								for v in graph[u]:
												if level[v] == -1:
																_SCREAMING_SNAKE_CASE     					=level[u] + 1
																q.put(a__)
																_SCREAMING_SNAKE_CASE     					=u
				return level, parent







def   lowerCamelCase(				):
				_SCREAMING_SNAKE_CASE     					=13
				# initializing with 0
				_SCREAMING_SNAKE_CASE     					=[[0 for _ in range(max_node + 10)] for _ in range(20)]
				# initializing with -1 which means every node is unvisited
				_SCREAMING_SNAKE_CASE     					=[-1 for _ in range(max_node + 10)]
				_SCREAMING_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: [],
				}
				_SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE     					=breadth_first_search(a__		,a__		,a__		,a__		,1)
				_SCREAMING_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()



from ..utils import DummyObject, requires_backends

class   A__							(						metaclass=UpperCamelCase__					):
						UpperCAmelCase     =  ["torch", "librosa"]




						def __init__(    self   : Dict			,      *_a   : Union[str, Any]			,      **_a   : List[str]					)							->       Optional[int]:


										"""simple docstring"""





										requires_backends(self			,      ['''torch''', '''librosa''']					)




						@classmethod
						def 							__UpperCamelCase			(    cls   : Dict			,      *_a   : Tuple			,      **_a   : Tuple					)							->       Optional[int]:


										"""simple docstring"""





										requires_backends(cls			,      ['''torch''', '''librosa''']					)




						@classmethod
						def 							__UpperCamelCase			(    cls   : List[Any]			,      *_a   : Any			,      **_a   : List[str]					)							->       Dict:


										"""simple docstring"""





										requires_backends(cls			,      ['''torch''', '''librosa''']					)

class   A__							(						metaclass=UpperCamelCase__					):
						UpperCAmelCase     =  ["torch", "librosa"]




						def __init__(    self   : List[Any]			,      *_a   : int			,      **_a   : int					)							->       Optional[Any]:


										"""simple docstring"""





										requires_backends(self			,      ['''torch''', '''librosa''']					)




						@classmethod
						def 							__UpperCamelCase			(    cls   : str			,      *_a   : Dict			,      **_a   : Optional[Any]					)							->       Union[str, Any]:


										"""simple docstring"""





										requires_backends(cls			,      ['''torch''', '''librosa''']					)




						@classmethod
						def 							__UpperCamelCase			(    cls   : List[str]			,      *_a   : Optional[int]			,      **_a   : Union[str, Any]					)							->       Optional[Any]:


										"""simple docstring"""





										requires_backends(cls			,      ['''torch''', '''librosa''']					)