




from __future__ import annotations

from queue import Queue


def 							__SCREAMING_SNAKE_CASE						(    snake_case_			,					snake_case_		):

						'''simple docstring'''


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


def 							__SCREAMING_SNAKE_CASE						(    snake_case_			,					snake_case_		):

						'''simple docstring'''


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


def 							__SCREAMING_SNAKE_CASE						(    snake_case_			,					snake_case_			,					snake_case_			,					snake_case_		):

						'''simple docstring'''


						if level[u] < level[v]:
												_UpperCAmelCase							,				_UpperCAmelCase									=  swap(snake_case_			,					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]:
																		_UpperCAmelCase									=  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]]:
																		_UpperCAmelCase							,				_UpperCAmelCase									=  parent[i][u], parent[i][v]
    # returning longest common ancestor of u,v
						return parent[0][u]


def 							__SCREAMING_SNAKE_CASE						(    snake_case_			,					snake_case_			,					snake_case_			,					snake_case_			,					snake_case_ = 1			,					):

						'''simple docstring'''


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


def 							__SCREAMING_SNAKE_CASE						(    ):

						'''simple docstring'''


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


if __name__ == "__main__":
				main()










def 							__SCREAMING_SNAKE_CASE						(    snake_case_ = 99_8001		):

						'''simple docstring'''


						for number in range(n - 1			,					9999			,					-1		):
												_UpperCAmelCase									=  str(snake_case_		)

												# checks whether 'str_number' is a palindrome.
												if str_number == str_number[::-1]:
																		_UpperCAmelCase									=  999

																		# if 'number' is a product of two 3-digit numbers
																		# then number is the answer otherwise fetch next number.
																		while divisor != 99:
																								if (number % divisor == 0) and (len(str(number // divisor		)		) == 3.0):
																														return number
																								divisor -= 1
						raise ValueError("That number is larger than our acceptable range."		)


if __name__ == "__main__":
				print(f"""{solution() = }""")




