






"""simple docstring"""
# Author: OMKAR PATHAK, Nwachukwu Chidiebere

# Use a Python dictionary to construct the graph.
from __future__ import annotations

from pprint import pformat
from typing import Generic, TypeVar

lowerCAmelCase__    						=			TypeVar('T')


class _lowerCAmelCase						(    Generic[T]       ):







						def __init__(    self   ,				lowerCAmelCase_ = True							)		->							None:
										_SCREAMING_SNAKE_CASE   :		dict[T, list[T]]       		=    {}  # dictionary of lists
										_SCREAMING_SNAKE_CASE   :		Any       		=    directed







						def 			A      (    self   ,				lowerCAmelCase_   ,				lowerCAmelCase_							)		->							GraphAdjacencyList[T]:

										if not self.directed:  # For undirected graphs
														# if both source vertex and destination vertex are both present in the
														# adjacency list, add destination vertex to source vertex list of adjacent
														# vertices and add source vertex to destination vertex list of adjacent
														# vertices.
														if source_vertex in self.adj_list and destination_vertex in self.adj_list:
																		self.adj_list[source_vertex].append(lowerCAmelCase_							)
																		self.adj_list[destination_vertex].append(lowerCAmelCase_							)
														# if only source vertex is present in adjacency list, add destination vertex
														# to source vertex list of adjacent vertices, then create a new vertex with
														# destination vertex as key and assign a list containing the source vertex
														# as it's first adjacent vertex.
														elif source_vertex in self.adj_list:
																		self.adj_list[source_vertex].append(lowerCAmelCase_							)
																		_SCREAMING_SNAKE_CASE   :		Any       		=    [source_vertex]
														# if only destination vertex is present in adjacency list, add source vertex
														# to destination vertex list of adjacent vertices, then create a new vertex
														# with source vertex as key and assign a list containing the source vertex
														# as it's first adjacent vertex.
														elif destination_vertex in self.adj_list:
																		self.adj_list[destination_vertex].append(lowerCAmelCase_							)
																		_SCREAMING_SNAKE_CASE   :		List[str]       		=    [destination_vertex]
														# if both source vertex and destination vertex are not present in adjacency
														# list, create a new vertex with source vertex as key and assign a list
														# containing the destination vertex as it's first adjacent vertex also
														# create a new vertex with destination vertex as key and assign a list
														# containing the source vertex as it's first adjacent vertex.
														else:
																		_SCREAMING_SNAKE_CASE   :		List[str]       		=    [destination_vertex]
																		_SCREAMING_SNAKE_CASE   :		Optional[Any]       		=    [source_vertex]
										else:  # For directed graphs
														# if both source vertex and destination vertex are present in adjacency
														# list, add destination vertex to source vertex list of adjacent vertices.
														if source_vertex in self.adj_list and destination_vertex in self.adj_list:
																		self.adj_list[source_vertex].append(lowerCAmelCase_							)
														# if only source vertex is present in adjacency list, add destination
														# vertex to source vertex list of adjacent vertices and create a new vertex
														# with destination vertex as key, which has no adjacent vertex
														elif source_vertex in self.adj_list:
																		self.adj_list[source_vertex].append(lowerCAmelCase_							)
																		_SCREAMING_SNAKE_CASE   :		Union[str, Any]       		=    []
														# if only destination vertex is present in adjacency list, create a new
														# vertex with source vertex as key and assign a list containing destination
														# vertex as first adjacent vertex
														elif destination_vertex in self.adj_list:
																		_SCREAMING_SNAKE_CASE   :		str       		=    [destination_vertex]
														# if both source vertex and destination vertex are not present in adjacency
														# list, create a new vertex with source vertex as key and a list containing
														# destination vertex as it's first adjacent vertex. Then create a new vertex
														# with destination vertex as key, which has no adjacent vertex
														else:
																		_SCREAMING_SNAKE_CASE   :		str       		=    [destination_vertex]
																		_SCREAMING_SNAKE_CASE   :		List[Any]       		=    []

										return self







						def __repr__(    self							)		->							str:
										return pformat(self.adj_list							)









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

from collections.abc import Generator





def 				lowercase__		(					):
				_SCREAMING_SNAKE_CASE   :		dict[int, int]       		=    {}
				_SCREAMING_SNAKE_CASE   :		List[Any]       		=    2
				while True:
								_SCREAMING_SNAKE_CASE   :		List[Any]       		=    factor_map.pop(lowerCamelCase,						lowerCamelCase       )
								if factor:
												_SCREAMING_SNAKE_CASE   :		str       		=    factor + prime
												while x in factor_map:
																x += factor
												_SCREAMING_SNAKE_CASE   :		Union[str, Any]       		=    factor
								else:
												_SCREAMING_SNAKE_CASE   :		Optional[int]       		=    prime
												yield prime
								prime += 1





def 				lowercase__		(					lowerCamelCase = 1E10       ):
				_SCREAMING_SNAKE_CASE   :		Dict       		=    sieve()

				_SCREAMING_SNAKE_CASE   :		Dict       		=    1
				while True:
								_SCREAMING_SNAKE_CASE   :		int       		=    next(lowerCamelCase       )
								if (2 * prime * n) > limit:
												return n
								# Ignore the next prime as the reminder will be 2.
								next(lowerCamelCase       )
								n += 2


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

