
"""simple docstring"""






import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


_lowerCamelCase     =  logging.get_logger(__name__)


_lowerCamelCase     =  '▁'

_lowerCamelCase     =  {'vocab_file': 'spiece.model'}

_lowerCamelCase     =  {
    'vocab_file': {
        'google/reformer-crime-and-punishment': (
            'https://huggingface.co/google/reformer-crime-and-punishment/resolve/main/spiece.model'
        )
    }
}

_lowerCamelCase     =  {
    'google/reformer-crime-and-punishment': 524288,
}


class 			lowerCamelCase_		(			lowercase   ):





				"""simple docstring"""







				_lowerCAmelCase      :      Optional[Any]      							=					VOCAB_FILES_NAMES
				_lowerCAmelCase      :      Tuple      							=					PRETRAINED_VOCAB_FILES_MAP
				_lowerCAmelCase      :      str      							=					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				_lowerCAmelCase      :      str      							=					["input_ids", "attention_mask"]



				def __init__(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__="</s>"       ,		UpperCAmelCase__="<unk>"       ,		UpperCAmelCase__=[]       ,		UpperCAmelCase__ = None       ,		**UpperCAmelCase__       ,		):
								SCREAMING_SNAKE_CASE__     							=				{} if sp_model_kwargs is None else sp_model_kwargs

								super().__init__(
								    eos_token=UpperCAmelCase__       ,		unk_token=UpperCAmelCase__       ,		additional_special_tokens=UpperCAmelCase__       ,		sp_model_kwargs=self.sp_model_kwargs       ,		**UpperCAmelCase__       ,		)

								SCREAMING_SNAKE_CASE__     							=				vocab_file
								SCREAMING_SNAKE_CASE__     							=				spm.SentencePieceProcessor(**self.sp_model_kwargs     )
								self.sp_model.Load(UpperCAmelCase__     )



				@property
				def   lowerCAmelCase__		(						self     ):
								return self.sp_model.get_piece_size()



				def   lowerCAmelCase__		(						self     ):
								SCREAMING_SNAKE_CASE__     							=				{self.convert_ids_to_tokens(UpperCAmelCase__     ): i for i in range(self.vocab_size     )}
								vocab.update(self.added_tokens_encoder     )
								return vocab



				def __getstate__(						self     ):
								SCREAMING_SNAKE_CASE__     							=				self.__dict__.copy()
								SCREAMING_SNAKE_CASE__     							=				None
								return state



				def __setstate__(						self       ,		UpperCAmelCase__     ):
								SCREAMING_SNAKE_CASE__     							=				d

								# for backward compatibility
								if not hasattr(self       ,		"sp_model_kwargs"     ):
												SCREAMING_SNAKE_CASE__     							=				{}

								SCREAMING_SNAKE_CASE__     							=				spm.SentencePieceProcessor(**self.sp_model_kwargs     )
								self.sp_model.Load(self.vocab_file     )



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__     ):
								return self.sp_model.encode(UpperCAmelCase__       ,		out_type=UpperCAmelCase__     )



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__     ):
								return self.sp_model.piece_to_id(UpperCAmelCase__     )



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__     ):
								if index < self.sp_model.get_piece_size():
												SCREAMING_SNAKE_CASE__     							=				self.sp_model.IdToPiece(UpperCAmelCase__     )
								return token



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__     ):
								SCREAMING_SNAKE_CASE__     							=				[]
								SCREAMING_SNAKE_CASE__     							=				""
								for token in tokens:
												# make sure that special tokens are not decoded using sentencepiece model
												if token in self.all_special_tokens:
																out_string += self.sp_model.decode(UpperCAmelCase__     ) + token
																SCREAMING_SNAKE_CASE__     							=				[]
												else:
																current_sub_tokens.append(UpperCAmelCase__     )
								out_string += self.sp_model.decode(UpperCAmelCase__     )
								return out_string.strip()






				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__ = None     ):
								if not os.path.isdir(UpperCAmelCase__     ):
												logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''     )
												return
								SCREAMING_SNAKE_CASE__     							=				os.path.join(
								    UpperCAmelCase__       ,		(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]     )

								if os.path.abspath(self.vocab_file     ) != os.path.abspath(UpperCAmelCase__     ) and os.path.isfile(self.vocab_file     ):
												copyfile(self.vocab_file       ,		UpperCAmelCase__     )
								elif not os.path.isfile(self.vocab_file     ):
												with open(UpperCAmelCase__       ,		"wb"     ) as fi:
																SCREAMING_SNAKE_CASE__     							=				self.sp_model.serialized_model_proto()
																fi.write(UpperCAmelCase__     )

								return (out_vocab_file,)




"""simple docstring"""






from math import sqrt


def __lowercase     (      lowerCamelCase_  :      int  ):
				SCREAMING_SNAKE_CASE__     							=				0
				for i in range(1						,					int(sqrt(lowerCamelCase_  ) + 1  )  ):
								if n % i == 0 and i != sqrt(lowerCamelCase_  ):
												total += i + n // i
								elif i == sqrt(lowerCamelCase_  ):
												total += i
				return total - n


def __lowercase     (      lowerCamelCase_  :      int = 10000  ):
				SCREAMING_SNAKE_CASE__     							=				sum(
				    i
				    for i in range(1						,					lowerCamelCase_  )
				    if sum_of_divisors(sum_of_divisors(lowerCamelCase_  )  ) == i and sum_of_divisors(lowerCamelCase_  ) != i  )
				return total


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