





'''simple docstring'''



import re
import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin






class 							__lowercase    ( lowerCAmelCase__  ):







	'''simple docstring'''

	a      :			Dict     =    ["image_processor", "tokenizer"]
	a      :			List[str]     =    "AutoImageProcessor"
	a      :			Tuple     =    "AutoTokenizer"


	def __init__(self       ,_lowerCamelCase=None       ,_lowerCamelCase=None       ,**_lowerCamelCase	)							->							Any:







				'''simple docstring'''





				__lowercase			  =							None
				if "feature_extractor" in kwargs:
							warnings.warn(
							    '''The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'''
							    ''' instead.'''       ,_lowerCamelCase       ,)
							__lowercase			  =							kwargs.pop('''feature_extractor'''	)

				__lowercase			  =							image_processor if image_processor is not None else feature_extractor
				if image_processor is None:
							raise ValueError('''You need to specify an `image_processor`.'''	)
				if tokenizer is None:
							raise ValueError('''You need to specify a `tokenizer`.'''	)

				super().__init__(_lowerCamelCase       ,_lowerCamelCase	)
				__lowercase			  =							self.image_processor
				__lowercase			  =							False


	def __call__(self       ,*_lowerCamelCase       ,**_lowerCamelCase	)							->							Tuple:







				'''simple docstring'''





				if self._in_target_context_manager:
							return self.current_processor(*_lowerCamelCase       ,**_lowerCamelCase	)

				__lowercase			  =							kwargs.pop('''images'''       ,_lowerCamelCase	)
				__lowercase			  =							kwargs.pop('''text'''       ,_lowerCamelCase	)
				if len(_lowerCamelCase	) > 0:
							__lowercase			  =							args[0]
							__lowercase			  =							args[1:]

				if images is None and text is None:
							raise ValueError('''You need to specify either an `images` or `text` input to process.'''	)

				if images is not None:
							__lowercase			  =							self.image_processor(_lowerCamelCase       ,*_lowerCamelCase       ,**_lowerCamelCase	)
				if text is not None:
							__lowercase			  =							self.tokenizer(_lowerCamelCase       ,**_lowerCamelCase	)

				if text is None:
							return inputs
				elif images is None:
							return encodings
				else:
							__lowercase			  =							encodings['''input_ids''']
							return inputs


	def   _UpperCAmelCase       (self       ,*_lowerCamelCase       ,**_lowerCamelCase	)							->							str:







				'''simple docstring'''





				return self.tokenizer.batch_decode(*_lowerCamelCase       ,**_lowerCamelCase	)


	def   _UpperCAmelCase       (self       ,*_lowerCamelCase       ,**_lowerCamelCase	)							->							Dict:







				'''simple docstring'''





				return self.tokenizer.decode(*_lowerCamelCase       ,**_lowerCamelCase	)


	@contextmanager
	def   _UpperCAmelCase       (self	)							->							Optional[Any]:







				'''simple docstring'''





				warnings.warn(
				    '''`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '''
				    '''labels by using the argument `text` of the regular `__call__` method (either in the same call as '''
				    '''your images inputs, or in a separate call.'''	)
				__lowercase			  =							True
				__lowercase			  =							self.tokenizer
				yield
				__lowercase			  =							self.image_processor
				__lowercase			  =							False


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase=False       ,_lowerCamelCase=None	)							->							List[str]:







				'''simple docstring'''





				if added_vocab is None:
							__lowercase			  =							self.tokenizer.get_added_vocab()

				__lowercase			  =							{}

				while tokens:
							__lowercase			  =							re.search(R'''<s_(.*?)>'''       ,_lowerCamelCase       ,re.IGNORECASE	)
							if start_token is None:
										break
							__lowercase			  =							start_token.group(1	)
							__lowercase			  =							re.search(Rf"</s_{key}>"       ,_lowerCamelCase       ,re.IGNORECASE	)
							__lowercase			  =							start_token.group()
							if end_token is None:
										__lowercase			  =							tokens.replace(_lowerCamelCase       ,''''''	)
							else:
										__lowercase			  =							end_token.group()
										__lowercase			  =							re.escape(_lowerCamelCase	)
										__lowercase			  =							re.escape(_lowerCamelCase	)
										__lowercase			  =							re.search(f"{start_token_escaped}(.*?){end_token_escaped}"       ,_lowerCamelCase       ,re.IGNORECASE	)
										if content is not None:
													__lowercase			  =							content.group(1	).strip()
													if r"<s_" in content and r"</s_" in content:  # non-leaf node
																__lowercase			  =							self.tokenajson(_lowerCamelCase       ,is_inner_value=_lowerCamelCase       ,added_vocab=_lowerCamelCase	)
																if value:
																			if len(_lowerCamelCase	) == 1:
																						__lowercase			  =							value[0]
																			__lowercase			  =							value
													else:  # leaf nodes
																__lowercase			  =							[]
																for leaf in content.split(R'''<sep/>'''	):
																			__lowercase			  =							leaf.strip()
																			if leaf in added_vocab and leaf[0] == "<" and leaf[-2:] == "/>":
																						__lowercase			  =							leaf[1:-2]  # for categorical special tokens
																			output[key].append(_lowerCamelCase	)
																if len(output[key]	) == 1:
																			__lowercase			  =							output[key][0]

										__lowercase			  =							tokens[tokens.find(_lowerCamelCase	) + len(_lowerCamelCase	) :].strip()
										if tokens[:6] == r"<sep/>":  # non-leaf nodes
													return [output] + self.tokenajson(tokens[6:]       ,is_inner_value=_lowerCamelCase       ,added_vocab=_lowerCamelCase	)

				if len(_lowerCamelCase	):
							return [output] if is_inner_value else output
				else:
							return [] if is_inner_value else {"text_sequence": tokens}


	@property
	def   _UpperCAmelCase       (self	)							->							List[Any]:







				'''simple docstring'''





				warnings.warn(
				    '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'''       ,_lowerCamelCase       ,)
				return self.image_processor_class


	@property
	def   _UpperCAmelCase       (self	)							->							Tuple:







				'''simple docstring'''





				warnings.warn(
				    '''`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'''       ,_lowerCamelCase       ,)
				return self.image_processor












'''simple docstring'''



from math import sqrt




def 				_lowerCAmelCase  (			lowerCamelCase_     :					int			):
			__lowercase			  =							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 				_lowerCAmelCase  (			lowerCamelCase_     :					int = 1_0_0_0_0			):
			__lowercase			  =							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())))





