

'''simple docstring'''
import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import BertTokenizer, BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_vision_available


if is_vision_available():
    from PIL import Image

    from transformers import ChineseCLIPImageProcessor, ChineseCLIPProcessor


@require_vision
class        a__  (							unittest.TestCase  ):


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				List[str]      					=       tempfile.mkdtemp()

      _lowercase      :				int      					=       [
          "[UNK]",
          "[CLS]",
          "[SEP]",
          "[PAD]",
          "[MASK]",
          "的",
          "价",
          "格",
          "是",
          "15",
          "便",
          "alex",
          "##andra",
          "，",
          "。",
          "-",
          "t",
          "shirt",
      ]
      _lowercase      :				Union[str, Any]      					=       os.path.join(self.tmpdirname      ,    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]  )  )

      _lowercase      :				Tuple      					=       {
          "do_resize": True,
          "size": {"height": 224, "width": 224},
          "do_center_crop": True,
          "crop_size": {"height": 18, "width": 18},
          "do_normalize": True,
          "image_mean": [0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3],
          "image_std": [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1],
          "do_convert_rgb": True,
      }
      _lowercase      :				Dict      					=       os.path.join(self.tmpdirname      ,    _UpperCamelCase  )
      with open(self.image_processor_file      ,    "w"      ,    encoding="utf-8"  ) as fp:
         json.dump(_UpperCamelCase      ,    _UpperCamelCase  )


   def 						_lowerCamelCase       (			self      ,    **_UpperCamelCase  ):





      """simple docstring"""





      return BertTokenizer.from_pretrained(self.tmpdirname      ,    **_UpperCamelCase  )


   def 						_lowerCamelCase       (			self      ,    **_UpperCamelCase  ):





      """simple docstring"""





      return BertTokenizerFast.from_pretrained(self.tmpdirname      ,    **_UpperCamelCase  )


   def 						_lowerCamelCase       (			self      ,    **_UpperCamelCase  ):





      """simple docstring"""





      return ChineseCLIPImageProcessor.from_pretrained(self.tmpdirname      ,    **_UpperCamelCase  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      shutil.rmtree(self.tmpdirname  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				int      					=       [np.random.randint(255      ,    size=(3, 30, 400)      ,    dtype=np.uinta  )]

      _lowercase      :				Dict      					=       [Image.fromarray(np.moveaxis(_UpperCamelCase      ,    0      ,    -1  )  ) for x in image_inputs]

      return image_inputs


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Optional[int]      					=       self.get_tokenizer()
      _lowercase      :				Any      					=       self.get_rust_tokenizer()
      _lowercase      :				Tuple      					=       self.get_image_processor()

      _lowercase      :				List[str]      					=       ChineseCLIPProcessor(tokenizer=_UpperCamelCase      ,    image_processor=_UpperCamelCase  )
      processor_slow.save_pretrained(self.tmpdirname  )
      _lowercase      :				Optional[Any]      					=       ChineseCLIPProcessor.from_pretrained(self.tmpdirname      ,    use_fast=_UpperCamelCase  )

      _lowercase      :				Union[str, Any]      					=       ChineseCLIPProcessor(tokenizer=_UpperCamelCase      ,    image_processor=_UpperCamelCase  )
      processor_fast.save_pretrained(self.tmpdirname  )
      _lowercase      :				Any      					=       ChineseCLIPProcessor.from_pretrained(self.tmpdirname  )

      self.assertEqual(processor_slow.tokenizer.get_vocab()      ,    tokenizer_slow.get_vocab()  )
      self.assertEqual(processor_fast.tokenizer.get_vocab()      ,    tokenizer_fast.get_vocab()  )
      self.assertEqual(tokenizer_slow.get_vocab()      ,    tokenizer_fast.get_vocab()  )
      self.assertIsInstance(processor_slow.tokenizer      ,    _UpperCamelCase  )
      self.assertIsInstance(processor_fast.tokenizer      ,    _UpperCamelCase  )

      self.assertEqual(processor_slow.image_processor.to_json_string()      ,    image_processor.to_json_string()  )
      self.assertEqual(processor_fast.image_processor.to_json_string()      ,    image_processor.to_json_string()  )
      self.assertIsInstance(processor_slow.image_processor      ,    _UpperCamelCase  )
      self.assertIsInstance(processor_fast.image_processor      ,    _UpperCamelCase  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				List[str]      					=       ChineseCLIPProcessor(tokenizer=self.get_tokenizer()      ,    image_processor=self.get_image_processor()  )
      processor.save_pretrained(self.tmpdirname  )

      _lowercase      :				Any      					=       self.get_tokenizer(cls_token="(CLS)"      ,    sep_token="(SEP)"  )
      _lowercase      :				Tuple      					=       self.get_image_processor(do_normalize=_UpperCamelCase  )

      _lowercase      :				Dict      					=       ChineseCLIPProcessor.from_pretrained(
          self.tmpdirname      ,    cls_token="(CLS)"      ,    sep_token="(SEP)"      ,    do_normalize=_UpperCamelCase  )

      self.assertEqual(processor.tokenizer.get_vocab()      ,    tokenizer_add_kwargs.get_vocab()  )
      self.assertIsInstance(processor.tokenizer      ,    _UpperCamelCase  )

      self.assertEqual(processor.image_processor.to_json_string()      ,    image_processor_add_kwargs.to_json_string()  )
      self.assertIsInstance(processor.image_processor      ,    _UpperCamelCase  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Tuple      					=       self.get_image_processor()
      _lowercase      :				List[Any]      					=       self.get_tokenizer()

      _lowercase      :				Tuple      					=       ChineseCLIPProcessor(tokenizer=_UpperCamelCase      ,    image_processor=_UpperCamelCase  )

      _lowercase      :				Union[str, Any]      					=       self.prepare_image_inputs()

      _lowercase      :				List[str]      					=       image_processor(_UpperCamelCase      ,    return_tensors="np"  )
      _lowercase      :				str      					=       processor(images=_UpperCamelCase      ,    return_tensors="np"  )

      for key in input_feat_extract.keys():
         self.assertAlmostEqual(input_feat_extract[key].sum()      ,    input_processor[key].sum()      ,    delta=1E-2  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				List[str]      					=       self.get_image_processor()
      _lowercase      :				str      					=       self.get_tokenizer()

      _lowercase      :				Optional[Any]      					=       ChineseCLIPProcessor(tokenizer=_UpperCamelCase      ,    image_processor=_UpperCamelCase  )

      _lowercase      :				Optional[Any]      					=       "Alexandra，T-shirt的价格是15便士。"

      _lowercase      :				Tuple      					=       processor(text=_UpperCamelCase  )

      _lowercase      :				Optional[int]      					=       tokenizer(_UpperCamelCase  )

      for key in encoded_tok.keys():
         self.assertListEqual(encoded_tok[key]      ,    encoded_processor[key]  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Optional[int]      					=       self.get_image_processor()
      _lowercase      :				Dict      					=       self.get_tokenizer()

      _lowercase      :				List[str]      					=       ChineseCLIPProcessor(tokenizer=_UpperCamelCase      ,    image_processor=_UpperCamelCase  )

      _lowercase      :				List[Any]      					=       "Alexandra，T-shirt的价格是15便士。"
      _lowercase      :				Union[str, Any]      					=       self.prepare_image_inputs()

      _lowercase      :				Any      					=       processor(text=_UpperCamelCase      ,    images=_UpperCamelCase  )

      self.assertListEqual(list(inputs.keys()  )      ,    ["input_ids", "token_type_ids", "attention_mask", "pixel_values"]  )

      # test if it raises when no input is passed
      with pytest.raises(_UpperCamelCase  ):
         processor()


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				str      					=       self.get_image_processor()
      _lowercase      :				Optional[int]      					=       self.get_tokenizer()

      _lowercase      :				Optional[int]      					=       ChineseCLIPProcessor(tokenizer=_UpperCamelCase      ,    image_processor=_UpperCamelCase  )

      _lowercase      :				Optional[Any]      					=       [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

      _lowercase      :				str      					=       processor.batch_decode(_UpperCamelCase  )
      _lowercase      :				Optional[Any]      					=       tokenizer.batch_decode(_UpperCamelCase  )

      self.assertListEqual(_UpperCamelCase      ,    _UpperCamelCase  )






   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Any      					=       self.get_image_processor()
      _lowercase      :				Dict      					=       self.get_tokenizer()

      _lowercase      :				Tuple      					=       ChineseCLIPProcessor(tokenizer=_UpperCamelCase      ,    image_processor=_UpperCamelCase  )

      _lowercase      :				Union[str, Any]      					=       "Alexandra，T-shirt的价格是15便士。"
      _lowercase      :				Optional[int]      					=       self.prepare_image_inputs()

      _lowercase      :				Union[str, Any]      					=       processor(text=_UpperCamelCase      ,    images=_UpperCamelCase  )

      self.assertListEqual(list(inputs.keys()  )      ,    processor.model_input_names  )









'''simple docstring'''
from math import sqrt







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







def  _A		(     snake_case = 1_00_00					)      ->     int:
   _lowercase      :				List[Any]      					=       sum(
       i
       for i in range(1		,							snake_case					)
       if sum_of_divisors(sum_of_divisors(snake_case					)					) == i and sum_of_divisors(snake_case					) != i					)
   return total


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






