





import json
import os
import pickle
import shutil
import tempfile
from unittest import TestCase
from unittest.mock import patch

import numpy as np
from datasets import Dataset

from transformers import is_faiss_available
from transformers.models.bart.configuration_bart import BartConfig
from transformers.models.bart.tokenization_bart import BartTokenizer
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES as DPR_VOCAB_FILES_NAMES
from transformers.models.dpr.configuration_dpr import DPRConfig
from transformers.models.dpr.tokenization_dpr import DPRContextEncoderTokenizer, DPRQuestionEncoderTokenizer
from transformers.models.rag.configuration_rag import RagConfig
from transformers.models.rag.retrieval_rag import CustomHFIndex, RagRetriever
from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES as BART_VOCAB_FILES_NAMES
from transformers.testing_utils import require_faiss, require_sentencepiece, require_tokenizers, require_torch


if is_faiss_available():
							import faiss

@require_faiss
class       __A     (						a    ):


				def _snake_case       (		self							):
								lowerCamelCase	 =tempfile.mkdtemp()
								lowerCamelCase	 =8

								# DPR tok
								lowerCamelCase	 =[
								    """[UNK]""",
								    """[CLS]""",
								    """[SEP]""",
								    """[PAD]""",
								    """[MASK]""",
								    """want""",
								    """##want""",
								    """##ed""",
								    """wa""",
								    """un""",
								    """runn""",
								    """##ing""",
								    """,""",
								    """low""",
								    """lowest""",
								]
								lowerCamelCase	 =os.path.join(self.tmpdirname   , """dpr_tokenizer"""							)
								os.makedirs(UpperCAmelCase_   , exist_ok=UpperCAmelCase_							)
								lowerCamelCase	 =os.path.join(UpperCAmelCase_   , DPR_VOCAB_FILES_NAMES["""vocab_file"""]							)
								with open(self.vocab_file   , """w"""   , encoding="""utf-8"""							) as vocab_writer:
												vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]							)							)

								# BART tok
								lowerCamelCase	 =[
								    """l""",
								    """o""",
								    """w""",
								    """e""",
								    """r""",
								    """s""",
								    """t""",
								    """i""",
								    """d""",
								    """n""",
								    """\u0120""",
								    """\u0120l""",
								    """\u0120n""",
								    """\u0120lo""",
								    """\u0120low""",
								    """er""",
								    """\u0120lowest""",
								    """\u0120newer""",
								    """\u0120wider""",
								    """<unk>""",
								]
								lowerCamelCase	 =dict(zip(UpperCAmelCase_   , range(len(UpperCAmelCase_							)							)							)							)
								lowerCamelCase	 =["""#version: 0.2""", """\u0120 l""", """\u0120l o""", """\u0120lo w""", """e r""", """"""]
								lowerCamelCase	 ={"""unk_token""": """<unk>"""}

								lowerCamelCase	 =os.path.join(self.tmpdirname   , """bart_tokenizer"""							)
								os.makedirs(UpperCAmelCase_   , exist_ok=UpperCAmelCase_							)
								lowerCamelCase	 =os.path.join(UpperCAmelCase_   , BART_VOCAB_FILES_NAMES["""vocab_file"""]							)
								lowerCamelCase	 =os.path.join(UpperCAmelCase_   , BART_VOCAB_FILES_NAMES["""merges_file"""]							)
								with open(self.vocab_file   , """w"""   , encoding="""utf-8"""							) as fp:
												fp.write(json.dumps(UpperCAmelCase_							) + """\n"""							)
								with open(self.merges_file   , """w"""   , encoding="""utf-8"""							) as fp:
												fp.write("""\n""".join(UpperCAmelCase_							)							)


				def _snake_case       (		self							):
								return DPRQuestionEncoderTokenizer.from_pretrained(os.path.join(self.tmpdirname   , """dpr_tokenizer"""							)							)


				def _snake_case       (		self							):
								return DPRContextEncoderTokenizer.from_pretrained(os.path.join(self.tmpdirname   , """dpr_tokenizer"""							)							)


				def _snake_case       (		self							):
								return BartTokenizer.from_pretrained(os.path.join(self.tmpdirname   , """bart_tokenizer"""							)							)


				def _snake_case       (		self							):
								shutil.rmtree(self.tmpdirname							)


				def _snake_case       (		self							):
								lowerCamelCase	 =Dataset.from_dict(
								    {
								        """id""": ["""0""", """1"""],
								        """text""": ["""foo""", """bar"""],
								        """title""": ["""Foo""", """Bar"""],
								        """embeddings""": [np.ones(self.retrieval_vector_size							), 2 * np.ones(self.retrieval_vector_size							)],
								    }							)
								dataset.add_faiss_index("""embeddings"""   , string_factory="""Flat"""   , metric_type=faiss.METRIC_INNER_PRODUCT							)
								return dataset


				def _snake_case       (		self							):
								lowerCamelCase	 =self.get_dummy_dataset()
								lowerCamelCase	 =RagConfig(
								    retrieval_vector_size=self.retrieval_vector_size   , question_encoder=DPRConfig().to_dict()   , generator=BartConfig().to_dict()   , )
								with patch("""transformers.models.rag.retrieval_rag.load_dataset"""							) as mock_load_dataset:
												lowerCamelCase	 =dataset
												lowerCamelCase	 =RagRetriever(
												    UpperCAmelCase_   , question_encoder_tokenizer=self.get_dpr_tokenizer()   , generator_tokenizer=self.get_bart_tokenizer()   , )
								return retriever


				def _snake_case       (		self   , UpperCAmelCase_							):
								lowerCamelCase	 =self.get_dummy_dataset()
								lowerCamelCase	 =RagConfig(
								    retrieval_vector_size=self.retrieval_vector_size   , question_encoder=DPRConfig().to_dict()   , generator=BartConfig().to_dict()   , index_name="""custom"""   , )
								if from_disk:
												lowerCamelCase	 =os.path.join(self.tmpdirname   , """dataset"""							)
												lowerCamelCase	 =os.path.join(self.tmpdirname   , """index.faiss"""							)
												dataset.get_index("""embeddings"""							).save(os.path.join(self.tmpdirname   , """index.faiss"""							)							)
												dataset.drop_index("""embeddings"""							)
												dataset.save_to_disk(os.path.join(self.tmpdirname   , """dataset"""							)							)
												del dataset
												lowerCamelCase	 =RagRetriever(
												    UpperCAmelCase_   , question_encoder_tokenizer=self.get_dpr_tokenizer()   , generator_tokenizer=self.get_bart_tokenizer()   , )
								else:
												lowerCamelCase	 =RagRetriever(
												    UpperCAmelCase_   , question_encoder_tokenizer=self.get_dpr_tokenizer()   , generator_tokenizer=self.get_bart_tokenizer()   , index=CustomHFIndex(config.retrieval_vector_size   , UpperCAmelCase_							)   , )
								return retriever


				def _snake_case       (		self							):
								lowerCamelCase	 =Dataset.from_dict(
								    {
								        """id""": ["""0""", """1"""],
								        """text""": ["""foo""", """bar"""],
								        """title""": ["""Foo""", """Bar"""],
								        """embeddings""": [np.ones(self.retrieval_vector_size + 1							), 2 * np.ones(self.retrieval_vector_size + 1							)],
								    }							)
								dataset.add_faiss_index("""embeddings"""   , string_factory="""Flat"""   , metric_type=faiss.METRIC_INNER_PRODUCT							)

								lowerCamelCase	 =os.path.join(self.tmpdirname   , """hf_bert_base.hnswSQ8_correct_phi_128.c_index"""							)
								dataset.save_faiss_index("""embeddings"""   , index_file_name + """.index.dpr"""							)
								pickle.dump(dataset["""id"""]   , open(index_file_name + """.index_meta.dpr"""   , """wb"""							)							)

								lowerCamelCase	 =os.path.join(self.tmpdirname   , """psgs_w100.tsv.pkl"""							)
								lowerCamelCase	 ={sample["""id"""]: [sample["""text"""], sample["""title"""]] for sample in dataset}
								pickle.dump(UpperCAmelCase_   , open(UpperCAmelCase_   , """wb"""							)							)

								lowerCamelCase	 =RagConfig(
								    retrieval_vector_size=self.retrieval_vector_size   , question_encoder=DPRConfig().to_dict()   , generator=BartConfig().to_dict()   , index_name="""legacy"""   , index_path=self.tmpdirname   , )
								lowerCamelCase	 =RagRetriever(
								    UpperCAmelCase_   , question_encoder_tokenizer=self.get_dpr_tokenizer()   , generator_tokenizer=self.get_bart_tokenizer()							)
								return retriever


				def _snake_case       (		self							):
								lowerCamelCase	 =1
								lowerCamelCase	 =self.get_dummy_canonical_hf_index_retriever()
								lowerCamelCase	 =np.array(
								    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =retriever.retrieve(UpperCAmelCase_   , n_docs=UpperCAmelCase_							)
								self.assertEqual(retrieved_doc_embeds.shape   , (2, n_docs, self.retrieval_vector_size)							)
								self.assertEqual(len(UpperCAmelCase_							)   , 2							)
								self.assertEqual(sorted(doc_dicts[0]							)   , ["""embeddings""", """id""", """text""", """title"""]							)
								self.assertEqual(len(doc_dicts[0]["""id"""]							)   , UpperCAmelCase_							)
								self.assertEqual(doc_dicts[0]["""id"""][0]   , """1"""							)  # max inner product is reached with second doc
								self.assertEqual(doc_dicts[1]["""id"""][0]   , """0"""							)  # max inner product is reached with first doc
								self.assertListEqual(doc_ids.tolist()   , [[1], [0]]							)


				def _snake_case       (		self							):
								lowerCamelCase	 =self.get_dummy_canonical_hf_index_retriever()
								with tempfile.TemporaryDirectory() as tmp_dirname:
												with patch("""transformers.models.rag.retrieval_rag.load_dataset"""							) as mock_load_dataset:
																lowerCamelCase	 =self.get_dummy_dataset()
																retriever.save_pretrained(UpperCAmelCase_							)
																lowerCamelCase	 =RagRetriever.from_pretrained(UpperCAmelCase_							)
																self.assertIsInstance(UpperCAmelCase_   , UpperCAmelCase_							)
																lowerCamelCase	 =np.array(
																    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
																lowerCamelCase	 =retriever.retrieve(UpperCAmelCase_   , n_docs=1							)
																self.assertTrue(out is not None							)


				def _snake_case       (		self							):
								lowerCamelCase	 =1
								lowerCamelCase	 =self.get_dummy_custom_hf_index_retriever(from_disk=UpperCAmelCase_							)
								lowerCamelCase	 =np.array(
								    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =retriever.retrieve(UpperCAmelCase_   , n_docs=UpperCAmelCase_							)
								self.assertEqual(retrieved_doc_embeds.shape   , (2, n_docs, self.retrieval_vector_size)							)
								self.assertEqual(len(UpperCAmelCase_							)   , 2							)
								self.assertEqual(sorted(doc_dicts[0]							)   , ["""embeddings""", """id""", """text""", """title"""]							)
								self.assertEqual(len(doc_dicts[0]["""id"""]							)   , UpperCAmelCase_							)
								self.assertEqual(doc_dicts[0]["""id"""][0]   , """1"""							)  # max inner product is reached with second doc
								self.assertEqual(doc_dicts[1]["""id"""][0]   , """0"""							)  # max inner product is reached with first doc
								self.assertListEqual(doc_ids.tolist()   , [[1], [0]]							)


				def _snake_case       (		self							):
								lowerCamelCase	 =self.get_dummy_custom_hf_index_retriever(from_disk=UpperCAmelCase_							)
								with tempfile.TemporaryDirectory() as tmp_dirname:
												retriever.save_pretrained(UpperCAmelCase_							)
												lowerCamelCase	 =RagRetriever.from_pretrained(UpperCAmelCase_							)
												self.assertIsInstance(UpperCAmelCase_   , UpperCAmelCase_							)
												lowerCamelCase	 =np.array(
												    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
												lowerCamelCase	 =retriever.retrieve(UpperCAmelCase_   , n_docs=1							)
												self.assertTrue(out is not None							)


				def _snake_case       (		self							):
								lowerCamelCase	 =1
								lowerCamelCase	 =self.get_dummy_custom_hf_index_retriever(from_disk=UpperCAmelCase_							)
								lowerCamelCase	 =np.array(
								    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =retriever.retrieve(UpperCAmelCase_   , n_docs=UpperCAmelCase_							)
								self.assertEqual(retrieved_doc_embeds.shape   , (2, n_docs, self.retrieval_vector_size)							)
								self.assertEqual(len(UpperCAmelCase_							)   , 2							)
								self.assertEqual(sorted(doc_dicts[0]							)   , ["""embeddings""", """id""", """text""", """title"""]							)
								self.assertEqual(len(doc_dicts[0]["""id"""]							)   , UpperCAmelCase_							)
								self.assertEqual(doc_dicts[0]["""id"""][0]   , """1"""							)  # max inner product is reached with second doc
								self.assertEqual(doc_dicts[1]["""id"""][0]   , """0"""							)  # max inner product is reached with first doc
								self.assertListEqual(doc_ids.tolist()   , [[1], [0]]							)


				def _snake_case       (		self							):
								lowerCamelCase	 =self.get_dummy_custom_hf_index_retriever(from_disk=UpperCAmelCase_							)
								with tempfile.TemporaryDirectory() as tmp_dirname:
												retriever.save_pretrained(UpperCAmelCase_							)
												lowerCamelCase	 =RagRetriever.from_pretrained(UpperCAmelCase_							)
												self.assertIsInstance(UpperCAmelCase_   , UpperCAmelCase_							)
												lowerCamelCase	 =np.array(
												    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
												lowerCamelCase	 =retriever.retrieve(UpperCAmelCase_   , n_docs=1							)
												self.assertTrue(out is not None							)


				def _snake_case       (		self							):
								lowerCamelCase	 =1
								lowerCamelCase	 =self.get_dummy_legacy_index_retriever()
								lowerCamelCase	 =np.array(
								    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =retriever.retrieve(UpperCAmelCase_   , n_docs=UpperCAmelCase_							)
								self.assertEqual(retrieved_doc_embeds.shape   , (2, n_docs, self.retrieval_vector_size)							)
								self.assertEqual(len(UpperCAmelCase_							)   , 2							)
								self.assertEqual(sorted(doc_dicts[0]							)   , ["""text""", """title"""]							)
								self.assertEqual(len(doc_dicts[0]["""text"""]							)   , UpperCAmelCase_							)
								self.assertEqual(doc_dicts[0]["""text"""][0]   , """bar"""							)  # max inner product is reached with second doc
								self.assertEqual(doc_dicts[1]["""text"""][0]   , """foo"""							)  # max inner product is reached with first doc
								self.assertListEqual(doc_ids.tolist()   , [[1], [0]]							)


				def _snake_case       (		self							):
								lowerCamelCase	 =self.get_dummy_legacy_index_retriever()
								with tempfile.TemporaryDirectory() as tmp_dirname:
												retriever.save_pretrained(UpperCAmelCase_							)
												lowerCamelCase	 =RagRetriever.from_pretrained(UpperCAmelCase_							)
												self.assertIsInstance(UpperCAmelCase_   , UpperCAmelCase_							)
												lowerCamelCase	 =np.array(
												    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
												lowerCamelCase	 =retriever.retrieve(UpperCAmelCase_   , n_docs=1							)
												self.assertTrue(out is not None							)


				@require_torch
				@require_tokenizers
				@require_sentencepiece
				def _snake_case       (		self							):
								import torch

								lowerCamelCase	 =1
								lowerCamelCase	 =self.get_dummy_canonical_hf_index_retriever()
								lowerCamelCase	 =[[5, 7], [10, 11]]
								lowerCamelCase	 =np.array(
								    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
								lowerCamelCase	 =retriever(UpperCAmelCase_   , UpperCAmelCase_   , prefix=retriever.config.generator.prefix   , n_docs=UpperCAmelCase_							)
								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =(
								    out["""context_input_ids"""],
								    out["""context_attention_mask"""],
								    out["""retrieved_doc_embeds"""],
								)
								self.assertEqual(retrieved_doc_embeds.shape   , (2, n_docs, self.retrieval_vector_size)							)
								self.assertIsInstance(UpperCAmelCase_   , UpperCAmelCase_							)
								self.assertIsInstance(UpperCAmelCase_   , UpperCAmelCase_							)
								self.assertIsInstance(UpperCAmelCase_   , np.ndarray							)

								lowerCamelCase	 =retriever(
								    UpperCAmelCase_   , UpperCAmelCase_   , prefix=retriever.config.generator.prefix   , n_docs=UpperCAmelCase_   , return_tensors="""pt"""   , )
								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =(  # noqa: F841
								    out["""context_input_ids"""],
								    out["""context_attention_mask"""],
								    out["""retrieved_doc_embeds"""],
								    out["""doc_ids"""],
								)
								self.assertEqual(retrieved_doc_embeds.shape   , (2, n_docs, self.retrieval_vector_size)							)
								self.assertIsInstance(UpperCAmelCase_   , torch.Tensor							)
								self.assertIsInstance(UpperCAmelCase_   , torch.Tensor							)
								self.assertIsInstance(UpperCAmelCase_   , torch.Tensor							)


				@require_torch
				@require_tokenizers
				@require_sentencepiece
				def _snake_case       (		self							):
								lowerCamelCase	 =self.get_dpr_ctx_encoder_tokenizer()
								lowerCamelCase	 =1
								lowerCamelCase	 =self.get_dummy_custom_hf_index_retriever(from_disk=UpperCAmelCase_							)
								retriever.set_ctx_encoder_tokenizer(UpperCAmelCase_							)

								lowerCamelCase	 =[[5, 7], [10, 11]]
								lowerCamelCase	 =np.array(
								    [np.ones(self.retrieval_vector_size							), -np.ones(self.retrieval_vector_size							)]   , dtype=np.floataa							)
								lowerCamelCase	 =retriever(UpperCAmelCase_   , UpperCAmelCase_   , prefix=retriever.config.generator.prefix   , n_docs=UpperCAmelCase_							)

								self.assertEqual(
								    len(UpperCAmelCase_							)   , 6							)  # check whether the retriever output consist of 6 attributes including tokenized docs
								self.assertEqual(
								    all(k in out for k in ("""tokenized_doc_ids""", """tokenized_doc_attention_mask""")							)   , UpperCAmelCase_							)  # check for doc token related keys in dictionary.












from math import sqrt





def      _lowercase					(						_UpperCAmelCase				)						->  int:
				lowerCamelCase	 =0
				for i in range(1			,      int(sqrt(_UpperCAmelCase				) + 1				)				):
								if n % i == 0 and i != sqrt(_UpperCAmelCase				):
												total += i + n // i
								elif i == sqrt(_UpperCAmelCase				):
												total += i
				return total - n





def      _lowercase					(						_UpperCAmelCase = 1_00_00				)						->  int:
				lowerCamelCase	 =sum(
				    i
				    for i in range(1			,      _UpperCAmelCase				)
				    if sum_of_divisors(sum_of_divisors(_UpperCAmelCase				)				) == i and sum_of_divisors(_UpperCAmelCase				) != i				)
				return total


if __name__ == "__main__":
							print(solution(int(str(input()).strip())))





