





"""simple docstring"""
from __future__ import annotations

from queue import Queue



def   __lowerCamelCase     (							a_  :	int				,     a_  :	int							)    ->   Tuple:
						a ^= b
						b ^= a
						a ^= b
						return a, b



def   __lowerCamelCase     (							a_  :	int				,     a_  :	list[list[int]]							)    ->   List[Any]:
						__SCREAMING_SNAKE_CASE     :str	       =						1
						while (1 << j) < max_node:
												for i in range(1				,     max_node + 1							):
																		__SCREAMING_SNAKE_CASE     :List[str]	       =						parent[j - 1][parent[j - 1][i]]
												j += 1
						return parent



def   __lowerCamelCase     (							a_  :	int				,     a_  :	int				,     a_  :	list[int]				,     a_  :	list[list[int]]							)    ->   Union[str, Any]:
						# u must be deeper in the tree than v
						if level[u] < level[v]:
												__SCREAMING_SNAKE_CASE     :List[Any]	       =						swap(UpperCamelCase__				,     UpperCamelCase__							)
						# 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     :Tuple	       =						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_  :	list[int]				,     a_  :	list[list[int]]				,     a_  :	int				,     a_  :	dict[int, list[int]]				,     a_  :	int = 1				,     )    ->   Optional[Any]:
						__SCREAMING_SNAKE_CASE     :Optional[Any]	       =						0
						__SCREAMING_SNAKE_CASE     :Queue[int]	       =						Queue(maxsize=UpperCamelCase__							)
						q.put(UpperCamelCase__							)
						while q.qsize() != 0:
												__SCREAMING_SNAKE_CASE     :Tuple	       =						q.get()
												for v in graph[u]:
																		if level[v] == -1:
																								__SCREAMING_SNAKE_CASE     :List[str]	       =						level[u] + 1
																								q.put(UpperCamelCase__							)
																								__SCREAMING_SNAKE_CASE     :Optional[Any]	       =						u
						return level, parent



def   __lowerCamelCase     (							)    ->   Optional[int]:
						__SCREAMING_SNAKE_CASE     :Tuple	       =						13
						# initializing with 0
						__SCREAMING_SNAKE_CASE     :Optional[Any]	       =						[[0 for _ in range(max_node + 10							)] for _ in range(20							)]
						# initializing with -1 which means every node is unvisited
						__SCREAMING_SNAKE_CASE     :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     :Optional[int]	       =						breadth_first_search(UpperCamelCase__				,     UpperCamelCase__				,     UpperCamelCase__				,     UpperCamelCase__				,     1							)
						__SCREAMING_SNAKE_CASE     :Dict	       =						create_sparse(UpperCamelCase__				,     UpperCamelCase__							)
						print('''LCA of node 1 and 3 is: '''				,     lowest_common_ancestor(1				,     3				,     UpperCamelCase__				,     UpperCamelCase__							)							)
						print('''LCA of node 5 and 6 is: '''				,     lowest_common_ancestor(5				,     6				,     UpperCamelCase__				,     UpperCamelCase__							)							)
						print('''LCA of node 7 and 11 is: '''				,     lowest_common_ancestor(7				,     11				,     UpperCamelCase__				,     UpperCamelCase__							)							)
						print('''LCA of node 6 and 7 is: '''				,     lowest_common_ancestor(6				,     7				,     UpperCamelCase__				,     UpperCamelCase__							)							)
						print('''LCA of node 4 and 12 is: '''				,     lowest_common_ancestor(4				,     12				,     UpperCamelCase__				,     UpperCamelCase__							)							)
						print('''LCA of node 8 and 8 is: '''				,     lowest_common_ancestor(8				,     8				,     UpperCamelCase__				,     UpperCamelCase__							)							)


if __name__ == "__main__":
		main()






"""simple docstring"""
def   __lowerCamelCase     (							a_  :	int = 10**6							)    ->   int:

      if n <= 0:
            raise ValueError('''Please enter an integer greater than 0'''							)

      __SCREAMING_SNAKE_CASE     :Tuple	       =						list(range(n + 1							)							)
      for number in range(2				,     n + 1							):
            if phi[number] == number:
                  phi[number] -= 1
                  for multiple in range(number * 2				,     n + 1				,     a_							):
                        __SCREAMING_SNAKE_CASE     :List[Any]	       =						(phi[multiple] // number) * (number - 1)

      __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						1
      for number in range(1				,     n + 1							):
            if (answer / phi[answer]) < (number / phi[number]):
                  __SCREAMING_SNAKE_CASE     :str	       =						number

      return answer


if __name__ == "__main__":
  print(solution())