




'''simple docstring'''

import warnings
from typing import List, Optional, Union

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType



class 		SCREAMING_SNAKE_CASE__  (			_UpperCamelCase	):
			__SCREAMING_SNAKE_CASE    =			["""image_processor""", """tokenizer"""]
			__SCREAMING_SNAKE_CASE    =			"""LayoutLMv3ImageProcessor"""
			__SCREAMING_SNAKE_CASE    =			("""LayoutLMv3Tokenizer""", """LayoutLMv3TokenizerFast""")





			def __init__(      self						:    str      ,		a_						:    Dict=None      ,		a_						:    Dict=None      ,		**a_						:    Optional[int]							):



						"""simple docstring"""




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

						__snake_case			=		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__(a_      ,		a_							)





			def __call__(      self						:    Any      ,		a_						:    Union[str, Any]      ,		a_						:    Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None      ,		a_						:    Optional[Union[PreTokenizedInput, List[PreTokenizedInput]]] = None      ,		a_						:    Union[List[List[int]], List[List[List[int]]]] = None      ,		a_						:    Optional[Union[List[int], List[List[int]]]] = None      ,		a_						:    bool = True      ,		a_						:    Union[bool, str, PaddingStrategy] = False      ,		a_						:    Union[bool, str, TruncationStrategy] = None      ,		a_						:    Optional[int] = None      ,		a_						:    int = 0      ,		a_						:    Optional[int] = None      ,		a_						:    Optional[bool] = None      ,		a_						:    Optional[bool] = None      ,		a_						:    bool = False      ,		a_						:    bool = False      ,		a_						:    bool = False      ,		a_						:    bool = False      ,		a_						:    bool = True      ,		a_						:    Optional[Union[str, TensorType]] = None      ,		**a_						:    Tuple      ,		):



						"""simple docstring"""




						if self.image_processor.apply_ocr and (boxes is not None):
									raise ValueError(
									    "You cannot provide bounding boxes if you initialized the image processor with apply_ocr set to True."							)

						if self.image_processor.apply_ocr and (word_labels is not None):
									raise ValueError(
									    "You cannot provide word labels if you initialized the image processor with apply_ocr set to True."							)

						# first, apply the image processor
						__snake_case			=		self.image_processor(images=a_      ,		return_tensors=a_							)

						# second, apply the tokenizer
						if text is not None and self.image_processor.apply_ocr and text_pair is None:
									if isinstance(a_      ,		a_							):
												__snake_case			=		[text]  # add batch dimension (as the image processor always adds a batch dimension)
									__snake_case			=		features["words"]

						__snake_case			=		self.tokenizer(
						    text=text if text is not None else features["words"]      ,		text_pair=text_pair if text_pair is not None else None      ,		boxes=boxes if boxes is not None else features["boxes"]      ,		word_labels=a_      ,		add_special_tokens=a_      ,		padding=a_      ,		truncation=a_      ,		max_length=a_      ,		stride=a_      ,		pad_to_multiple_of=a_      ,		return_token_type_ids=a_      ,		return_attention_mask=a_      ,		return_overflowing_tokens=a_      ,		return_special_tokens_mask=a_      ,		return_offsets_mapping=a_      ,		return_length=a_      ,		verbose=a_      ,		return_tensors=a_      ,		**a_      ,		)

						# add pixel values
						__snake_case			=		features.pop("pixel_values"							)
						if return_overflowing_tokens is True:
									__snake_case			=		self.get_overflowing_images(a_      ,		encoded_inputs["overflow_to_sample_mapping"]							)
						__snake_case			=		images

						return encoded_inputs





			def 							A (      self						:    List[Any]      ,		a_						:    int      ,		a_						:    int							):



						"""simple docstring"""




						__snake_case			=		[]
						for sample_idx in overflow_to_sample_mapping:
									images_with_overflow.append(images[sample_idx]							)

						if len(a_							) != len(a_							):
									raise ValueError(
									    "Expected length of images to be the same as the length of `overflow_to_sample_mapping`, but got"
									    f''' {len(a_							)} and {len(a_							)}'''							)

						return images_with_overflow





			def 							A (      self						:    str      ,		*a_						:    str      ,		**a_						:    List[str]							):



						"""simple docstring"""




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





			def 							A (      self						:    str      ,		*a_						:    int      ,		**a_						:    Tuple							):



						"""simple docstring"""




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





			@property
			def 							A (      self						:    Dict							):



						"""simple docstring"""




						return ["input_ids", "bbox", "attention_mask", "pixel_values"]





			@property
			def 							A (      self						:    int							):



						"""simple docstring"""




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






			@property
			def 							A (      self						:    Dict							):



						"""simple docstring"""




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







from math import sqrt






def   lowerCamelCase__							(							__lowerCAmelCase    :    int							):




			"""simple docstring"""


			lowerCAmelCase_         =      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 = 10000							):




			"""simple docstring"""


			lowerCAmelCase_         =      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())))



