





class 						_A:


				"""simple docstring"""


				def __init__(			self     ,					_A     ):
									__A	:						Tuple       =				set_counts
									__A	:						Union[str, Any]       =				max(_A     )
									__A	:						List[str]       =				len(_A     )
									__A	:						Union[str, Any]       =				[1] * num_sets
									__A	:						int       =				list(range(_A     )     )



				def 					UpperCAmelCase_		(			self     ,					_A     ,					_A     ):
									__A	:						Tuple       =				self.get_parent(_A     )
									__A	:						Dict       =				self.get_parent(_A     )

									if src_parent == dst_parent:
														return False

									if self.ranks[dst_parent] >= self.ranks[src_parent]:
														self.set_counts[dst_parent] += self.set_counts[src_parent]
														__A	:						Optional[Any]       =				0
														__A	:						int       =				dst_parent
														if self.ranks[dst_parent] == self.ranks[src_parent]:
																			self.ranks[dst_parent] += 1
														__A	:						List[str]       =				self.set_counts[dst_parent]
									else:
														self.set_counts[src_parent] += self.set_counts[dst_parent]
														__A	:						Any       =				0
														__A	:						Optional[int]       =				src_parent
														__A	:						Optional[Any]       =				self.set_counts[src_parent]

									__A	:						List[str]       =				max(self.max_set     ,					_A     )
									return True





				def 					UpperCAmelCase_		(			self     ,					_A     ):
									if self.parents[disj_set] == disj_set:
														return disj_set
									__A	:						Union[str, Any]       =				self.get_parent(self.parents[disj_set]     )
									return self.parents[disj_set]











import math







def  _SCREAMING_SNAKE_CASE				(   a  )      ->      list[int]:
					__A	:						List[str]       =				[]
					__A	:						Any       =				2
					__A	:						Union[str, Any]       =				int(math.sqrt(a  )  )  # Size of every segment
					__A	:						Any       =				[True] * (end + 1)
					__A	:						List[Any]       =				[]

					while start <= end:
										if temp[start] is True:
															in_prime.append(a  )
															for i in range(start * start					,						end + 1					,						a  ):
																				__A	:						Optional[int]       =				False
										start += 1
					prime += in_prime

					__A	:						Any       =				end + 1
					__A	:						Any       =				min(2 * end					,						a  )

					while low <= n:
										__A	:						List[Any]       =				[True] * (high - low + 1)
										for each in in_prime:
															__A	:						List[str]       =				math.floor(low / each  ) * each
															if t < low:
																				t += each

															for j in range(a					,						high + 1					,						a  ):
																				__A	:						Optional[int]       =				False

										for j in range(len(a  )  ):
															if temp[j] is True:
																				prime.append(j + low  )

										__A	:						Optional[int]       =				high + 1
										__A	:						Tuple       =				min(high + end					,						a  )

					return prime




print(sieve(10**6))




