
def 				A__    (  lowerCamelCase = 10**6  )     ->		int:

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

				UpperCamelCase_:							Dict		=  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   ,			lowerCamelCase  ):
																UpperCamelCase_:							Optional[int]		=  (phi[multiple] // number) * (number - 1)

				UpperCamelCase_:							List[str]		=  1
				for number in range(1   ,			n + 1  ):
								if (answer / phi[answer]) < (number / phi[number]):
												UpperCamelCase_:							Tuple		=  number

				return answer


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








import torch

from transformers import AutoTokenizer

class 				_UpperCamelCase (    _A     ):






			'''simple docstring'''

			def __init__(				self       :				List[str]  ,		snake_case_       :				Dict					):
							UpperCamelCase_:							int		=  AutoTokenizer.from_pretrained(snake_case_					)

			def 					lowerCAmelCase__		(				self       :				Union[str, Any]  ,		snake_case_       :				Optional[Any]					):

							if isinstance(snake_case_  ,		snake_case_					) and all(isinstance(_x  ,		snake_case_					) for _x in x					):
											UpperCamelCase_:							Tuple		=  None
											for l in x:
															UpperCamelCase_:							Optional[Any]		=  self.tokenizer(
															    snake_case_  ,		padding="""max_length"""  ,		max_length=384  ,		truncation=snake_case_  ,		return_tensors="""pt"""  ,		)
															UpperCamelCase_:							str		=  torch.tensor([len(snake_case_					)]					)
															if d is not None:
																			for k in d.keys():
																							UpperCamelCase_:							List[Any]		=  torch.cat((d[k], t[k])  ,		0					)
															else:
																			UpperCamelCase_:							Optional[int]		=  t

											UpperCamelCase_:							Union[str, Any]		=  torch.tensor(self.tokenizer.convert_tokens_to_ids("""[E]"""					)					)
											UpperCamelCase_:							List[str]		=  torch.tensor(self.tokenizer.convert_tokens_to_ids("""[/E]"""					)					)

							elif isinstance(snake_case_  ,		snake_case_					) and all(isinstance(_x  ,		snake_case_					) for _x in x					):
											UpperCamelCase_:							List[str]		=  self.tokenizer(
											    snake_case_  ,		padding="""max_length"""  ,		max_length=384  ,		truncation=snake_case_  ,		return_tensors="""pt"""  ,		)

							else:
											raise Exception(
											    """Type of parameter x was not recognized! Only `list of strings` for query or `list of lists of"""
											    """ strings` for supports are supported."""					)

							return d




			def 					lowerCAmelCase__		(				self       :				int  ,		snake_case_       :				List[str]  ,		snake_case_       :				Optional[int]  ,		snake_case_       :				Optional[Any]  ,		snake_case_       :				Optional[int]  ,		snake_case_       :				List[Any]=0.70					):
							UpperCamelCase_:							int		=  []
							for idx in range(len(W_query["""input_ids"""]					)					):
											UpperCamelCase_:							List[str]		=  range(p_start.shape[1]					)

											UpperCamelCase_:							str		=  []
											for start_id in start_indexes:
															for end_id in end_indexes:
																			if start_id < end_id:
																							output.append(
																							    (
																							        start_id,
																							        end_id,
																							        p_start[idx][start_id].item(),
																							        p_end[idx][end_id].item(),
																							    )					)

											output.sort(key=lambda snake_case_					: (tup[2] * tup[3])  ,		reverse=snake_case_					)
											UpperCamelCase_:							Optional[int]		=  []
											for k in range(len(snake_case_					)					):
															if output[k][2] * output[k][3] >= thresh:
																			UpperCamelCase_,      UpperCamelCase_:							Tuple		=  output[k][0], output[k][1]
																			UpperCamelCase_:							Any		=  self.tokenizer.decode(W_query["""input_ids"""][idx][c_start_pos:c_end_pos]					)
																			temp.append((decoded, output[k][2] * output[k][3])					)

											final_outputs.append(snake_case_					)

							return final_outputs






