



'''simple docstring'''

from __future__ import annotations

import os
import tempfile
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import is_tensorflow_text_available, is_tf_available
from transformers.testing_utils import require_tensorflow_text, require_tf, slow

from ..test_modeling_tf_common import floats_tensor
from .test_framework_agnostic import GenerationIntegrationTestsMixin


if is_tf_available():
							import tensorflow as tf

							from transformers import (
							    AutoTokenizer,
							    TFAutoModelForCausalLM,
							    TFAutoModelForSeqaSeqLM,
							    TFAutoModelForSpeechSeqaSeq,
							    TFAutoModelForVisionaSeq,
							    TFBartForConditionalGeneration,
							    TFLogitsProcessorList,
							    TFMinLengthLogitsProcessor,
							    tf_top_k_top_p_filtering,
							)

if is_tensorflow_text_available():
							import tensorflow_text as text

@require_tf
class      __magic_name__						(   unittest.TestCase       ):







							def 							__lowercase      (							self :	int		):
									_a					:				List[Any]				=							tf.convert_to_tensor(
									    [
									        [
									            8.2_22_09_91,  # 3rd highest value; idx. 0
									            -0.5_62_00_44,
									            5.23_22_97_52,
									            4.0_38_63_93,
									            -6.8_79_83_78,
									            -0.54_78_58_02,
									            -3.2_01_21_53,
									            2.92_77_71_76,
									            1.88_17_19_53,
									            7.35_34_12_76,  # 5th highest value; idx. 9
									            8.43_20_78_33,  # 2nd highest value; idx. 10
									            -9.85_71_18_36,
									            -5.96_20_92_36,
									            -1.13_03_91_61,
									            -7.1_11_52_94,
									            -0.8_36_96_33,
									            -5.3_18_64_08,
									            7.06_42_74_07,
									            0.81_36_93_44,
									            -0.82_02_38_17,
									            -5.9_17_97_96,
									            0.58_81_34_43,
									            -6.99_77_84_38,
									            4.71_55_11_89,
									            -0.18_77_16_37,
									            7.44_02_07_59,  # 4th highest value; idx. 25
									            9.38_45_09_87,  # 1st highest value; idx. 26
									            2.12_66_29_41,
									            -9.32_56_20_38,
									            2.35_65_25_22,
									        ],  # cummulative prob of 5 highest values <= 0.6
									        [
									            0.58_42_55_18,
									            4.53_13_92_38,
									            -5.57_51_04_64,
									            -6.28_03_06_99,
									            -7.19_52_95_03,
									            -4.02_12_25_51,
									            1.39_33_70_37,
									            -6.06_70_70_57,
									            1.59_48_05_17,
									            -9.64_31_19,
									            0.03_90_77_99,
									            0.67_23_17_62,
									            -8.88_20_67_26,
									            6.27_11_59_22,  # 4th highest value; idx. 13
									            2.28_52_07_23,
									            4.82_76_75_06,
									            4.30_42_13_68,
									            8.8_27_53_13,  # 2nd highest value; idx. 17
									            5.44_02_99_58,  # 5th highest value; idx. 18
									            -4.4_73_57_94,
									            7.38_57_95_36,  # 3rd highest value; idx. 20
									            -2.91_05_16_63,
									            2.61_94_60_77,
									            -2.5_67_47_62,
									            -9.48_95_93_02,
									            -4.02_92_26_45,
									            -1.35_41_69_18,
									            9.67_70_23_23,  # 1st highest value; idx. 27
									            -5.89_47_85_53,
									            1.85_37_04_67,
									        ],  # cummulative prob of 5 highest values <= 0.6
									    ]     ,dtype=tf.floataa     ,)

									_a					:				Union[str, Any]				=							tf.convert_to_tensor(
									    [[0, 0], [0, 9], [0, 10], [0, 25], [0, 26], [1, 13], [1, 17], [1, 18], [1, 20], [1, 27]]     ,dtype=tf.intaa     ,)  # expected non filtered idx as noted above

									_a					:				Dict				=							tf.convert_to_tensor(
									    [8.22_20_99, 7.3_53_41_26, 8.43_20_78, 7.4_40_20_75, 9.3_84_51, 6.27_11_59, 8.82_75_31, 5.4_40_29_95, 7.3_85_79_56, 9.67_70_23]     ,dtype=tf.floataa     ,)  # expected non filtered values as noted above

									_a					:				Optional[int]				=							tf_top_k_top_p_filtering(_UpperCAmelCase     ,top_k=10     ,top_p=0.6     ,min_tokens_to_keep=4		)

									_a					:				List[str]				=							output[output != -float('inf'		)]
									_a					:				Union[str, Any]				=							tf.cast(
									    tf.where(tf.not_equal(_UpperCAmelCase     ,tf.constant(-float('inf'		)     ,dtype=tf.floataa		)		)		)     ,dtype=tf.intaa     ,)

									tf.debugging.assert_near(_UpperCAmelCase     ,_UpperCAmelCase     ,rtol=1E-12		)
									tf.debugging.assert_equal(_UpperCAmelCase     ,_UpperCAmelCase		)

@require_tf
class      __magic_name__						(   unittest.TestCase      ,						_UpperCamelCase       ):
							# setting framework_dependent_parameters needs to be gated, just like its contents' imports
							if is_tf_available():
														lowerCAmelCase	:   Dict           = {
														    'AutoModelForCausalLM': TFAutoModelForCausalLM,
														    'AutoModelForSpeechSeq2Seq': TFAutoModelForSpeechSeqaSeq,
														    'AutoModelForSeq2SeqLM': TFAutoModelForSeqaSeqLM,
														    'AutoModelForVision2Seq': TFAutoModelForVisionaSeq,
														    'LogitsProcessorList': TFLogitsProcessorList,
														    'MinLengthLogitsProcessor': TFMinLengthLogitsProcessor,
														    'create_tensor_fn': tf.convert_to_tensor,
														    'floats_tensor': floats_tensor,
														    'return_tensors': 'tf',
														}







							@slow
							def 							__lowercase      (							self :	List[Any]		):
									# TF-only test: tf.saved_model export
									_a					:				Dict				=							TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'		)
									_a					:				Optional[Any]				=							2
									_a					:				List[Any]				=							2

									class      __magic_name__						(   tf.Module       ):







																def __init__(							self :	Optional[int]     ,_UpperCAmelCase :	Optional[int]		):
																		super(_UpperCAmelCase     ,self		).__init__()
																		_a					:				Any				=							model







																@tf.function(
																    input_signature=(
																        tf.TensorSpec((None, input_length)     ,tf.intaa     ,name='input_ids'		),
																        tf.TensorSpec((None, input_length)     ,tf.intaa     ,name='attention_mask'		),
																    )     ,jit_compile=_UpperCAmelCase     ,)
																def 							__lowercase      (							self :	Optional[Any]     ,_UpperCAmelCase :	List[Any]     ,_UpperCAmelCase :	int		):
																		_a					:				Dict				=							self.model.generate(
																		    input_ids=_UpperCAmelCase     ,attention_mask=_UpperCAmelCase     ,max_new_tokens=_UpperCAmelCase     ,return_dict_in_generate=_UpperCAmelCase     ,)
																		return {"sequences": outputs["sequences"]}
									_a					:				Union[str, Any]				=							[[2, 0], [102, 103]]
									_a					:				Union[str, Any]				=							[[1, 0], [1, 1]]
									_a					:				Union[str, Any]				=							DummyModel(model=_UpperCAmelCase		)
									with tempfile.TemporaryDirectory() as tmp_dir:
											tf.saved_model.save(_UpperCAmelCase     ,_UpperCAmelCase     ,signatures={'serving_default': dummy_model.serving}		)
											_a					:				Optional[int]				=							tf.saved_model.load(_UpperCAmelCase		).signatures['serving_default']
											for batch_size in range(1     ,len(_UpperCAmelCase		) + 1		):
													_a					:				Optional[int]				=							{
													    'input_ids': tf.constant(dummy_input_ids[:batch_size]		),
													    'attention_mask': tf.constant(dummy_attention_masks[:batch_size]		),
													}
													_a					:				int				=							serving_func(**_UpperCAmelCase		)['sequences']
													_a					:				Optional[int]				=							test_model.generate(**_UpperCAmelCase     ,max_new_tokens=_UpperCAmelCase		)
													tf.debugging.assert_equal(_UpperCAmelCase     ,_UpperCAmelCase		)







							@slow
							def 							__lowercase      (							self :	Tuple		):
									# TF-only test: tf.saved_model export
									_a					:				Optional[int]				=							TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'		)
									_a					:				Optional[Any]				=							1
									_a					:				Tuple				=							2

									class      __magic_name__						(   tf.Module       ):







																def __init__(							self :	str     ,_UpperCAmelCase :	List[Any]		):
																		super(_UpperCAmelCase     ,self		).__init__()
																		_a					:				Optional[Any]				=							model







																@tf.function(
																    input_signature=(
																        tf.TensorSpec((batch_size, None)     ,tf.intaa     ,name='input_ids'		),
																        tf.TensorSpec((batch_size, None)     ,tf.intaa     ,name='attention_mask'		),
																    )     ,jit_compile=_UpperCAmelCase     ,)
																def 							__lowercase      (							self :	Tuple     ,_UpperCAmelCase :	Tuple     ,_UpperCAmelCase :	Tuple		):
																		_a					:				Any				=							self.model.generate(
																		    input_ids=_UpperCAmelCase     ,attention_mask=_UpperCAmelCase     ,max_new_tokens=_UpperCAmelCase     ,return_dict_in_generate=_UpperCAmelCase     ,)
																		return {"sequences": outputs["sequences"]}
									_a					:				str				=							[[2], [102, 103]]
									_a					:				Dict				=							[[1], [1, 1]]
									_a					:				Tuple				=							DummyModel(model=_UpperCAmelCase		)
									with tempfile.TemporaryDirectory() as tmp_dir:
											tf.saved_model.save(_UpperCAmelCase     ,_UpperCAmelCase     ,signatures={'serving_default': dummy_model.serving}		)
											_a					:				Optional[Any]				=							tf.saved_model.load(_UpperCAmelCase		).signatures['serving_default']
											for input_row in range(len(_UpperCAmelCase		)		):
													_a					:				Union[str, Any]				=							{
													    'input_ids': tf.constant([dummy_input_ids[input_row]]		),
													    'attention_mask': tf.constant([dummy_attention_masks[input_row]]		),
													}
													_a					:				Any				=							serving_func(**_UpperCAmelCase		)['sequences']
													_a					:				Optional[Any]				=							test_model.generate(**_UpperCAmelCase     ,max_new_tokens=_UpperCAmelCase		)
													tf.debugging.assert_equal(_UpperCAmelCase     ,_UpperCAmelCase		)







							@slow
							@require_tensorflow_text
							def 							__lowercase      (							self :	Optional[Any]		):
									# TF-only test: tf.saved_model export
									with tempfile.TemporaryDirectory() as tmp_dir:
											# file needed to load the TF tokenizer
											hf_hub_download(repo_id='google/flan-t5-small'     ,filename='spiece.model'     ,local_dir=_UpperCAmelCase		)

											class      __magic_name__						(   tf.keras.layers.Layer       ):







																		def __init__(							self :	List[str]		):
																				super().__init__()
																				_a					:				Optional[int]				=							text.SentencepieceTokenizer(
																				    model=tf.io.gfile.GFile(os.path.join(_UpperCAmelCase     ,'spiece.model'		)     ,'rb'		).read()		)
																				_a					:				str				=							TFAutoModelForSeqaSeqLM.from_pretrained('hf-internal-testing/tiny-random-t5'		)







																		def 							__lowercase      (							self :	Optional[Any]     ,_UpperCAmelCase :	str     ,*_UpperCAmelCase :	List[Any]     ,**_UpperCAmelCase :	str		):
																				_a					:				int				=							self.tokenizer.tokenize(_UpperCAmelCase		)
																				_a					:				Dict				=							text.pad_model_inputs(
																				    _UpperCAmelCase     ,max_seq_length=64     ,pad_value=self.model.config.pad_token_id		)
																				_a					:				Tuple				=							self.model.generate(input_ids=_UpperCAmelCase     ,attention_mask=_UpperCAmelCase		)
																				return self.tokenizer.detokenize(_UpperCAmelCase		)
											_a					:				List[Any]				=							CompleteSentenceTransformer()
											_a					:				Optional[int]				=							tf.keras.layers.Input(shape=(1,)     ,dtype=tf.string     ,name='inputs'		)
											_a					:				List[str]				=							complete_model(_UpperCAmelCase		)
											_a					:				List[Any]				=							tf.keras.Model(_UpperCAmelCase     ,_UpperCAmelCase		)
											keras_model.save(_UpperCAmelCase		)







							def 							__lowercase      (							self :	Tuple		):
									# Has PT equivalent: this test relies on random sampling
									_a					:				Any				=							{
									    'do_sample': True,
									    'num_beams': 1,
									    'top_p': 0.7,
									    'top_k': 10,
									    'temperature': 0.7,
									}
									_a					:				Any				=							14

									_a					:				Optional[Any]				=							AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-gpt2'		)
									_a					:				Tuple				=							'Hello, my dog is cute and'
									_a					:				Optional[int]				=							tokenizer(_UpperCAmelCase     ,return_tensors='tf'		)
									_a					:				Tuple				=							TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'		)

									_a					:				Tuple				=							638
									# forces the generation to happen on CPU, to avoid GPU-related quirks
									with tf.device(':/CPU:0'		):
											tf.random.set_seed(0		)
											_a					:				Any				=							model.generate(**_UpperCAmelCase     ,eos_token_id=_UpperCAmelCase     ,**_UpperCAmelCase		)
									self.assertTrue(expectation == len(generated_tokens[0]		)		)

									_a					:				Optional[int]				=							[638, 198]
									with tf.device(':/CPU:0'		):
											tf.random.set_seed(0		)
											_a					:				Optional[int]				=							model.generate(**_UpperCAmelCase     ,eos_token_id=_UpperCAmelCase     ,**_UpperCAmelCase		)
									self.assertTrue(expectation == len(generated_tokens[0]		)		)







							def 							__lowercase      (							self :	List[Any]		):
									# Has PT equivalent: ample use of framework-specific code
									_a					:				Optional[Any]				=							AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-bart'		)
									_a					:				List[Any]				=							'Hugging Face is a technology company based in New York and Paris.'
									_a					:				Any				=							bart_tokenizer(_UpperCAmelCase     ,return_tensors='tf'		).input_ids
									_a					:				Any				=							TFBartForConditionalGeneration.from_pretrained('hf-internal-testing/tiny-random-bart'		)
									_a					:				List[str]				=							bart_model.generate(_UpperCAmelCase		).numpy()

									class      __magic_name__						(   _UpperCamelCase       ):







																def 							__lowercase      (							self :	Optional[int]     ,_UpperCAmelCase :	Any     ,_UpperCAmelCase :	List[str]=None     ,**_UpperCAmelCase :	Any		):
																		return super().call(_UpperCAmelCase     ,**_UpperCAmelCase		)
									_a					:				Any				=							FakeBart.from_pretrained('hf-internal-testing/tiny-random-bart'		)
									_a					:				Optional[int]				=							bart_model.generate(_UpperCAmelCase     ,foo='bar'		).numpy()
									self.assertTrue(np.array_equal(_UpperCAmelCase     ,_UpperCAmelCase		)		)

									class      __magic_name__						(   bart_model.model.encoder.__class__       ):







																def 							__lowercase      (							self :	Dict     ,_UpperCAmelCase :	Optional[Any]     ,**_UpperCAmelCase :	int		):
																		return super().call(_UpperCAmelCase     ,**_UpperCAmelCase		)
									_a					:				Dict				=							FakeEncoder(bart_model.config     ,bart_model.model.shared		)
									_a					:				Optional[int]				=							fake_encoder

									# Normal generation still works (the output will be different because the encoder weights are different)
									_a					:				Union[str, Any]				=							bart_model.generate(_UpperCAmelCase		).numpy()
									with self.assertRaises(_UpperCAmelCase		):
											# FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo"
											bart_model.generate(_UpperCAmelCase     ,foo='bar'		)









'''simple docstring'''

from math import sqrt



def 					__lowerCamelCase					(				lowerCAmelCase_  )      ->				int:
		_a					:				Dict				=							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_ = 10000  )      ->				int:
		_a					:				Union[str, Any]				=							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())))




