





import os
import unittest

from transformers import RealmTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.models.realm.tokenization_realm import RealmTokenizer
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english

@require_tokenizers
class 		snake_case_      (       UpperCAmelCase_    ,    unittest.TestCase	):







	'''simple docstring'''
	__UpperCamelCase        =		RealmTokenizer
	__UpperCamelCase        =		RealmTokenizerFast
	__UpperCamelCase        =		True
	__UpperCamelCase        =		True
	__UpperCamelCase        =		filter_non_english




	def       UpperCAmelCase (	self       :    List[str]      )					->   List[Any]:

			'''simple docstring'''




			super().setUp()

			__lowercase					=    [
			    '[UNK]',
			    '[CLS]',
			    '[SEP]',
			    '[PAD]',
			    '[MASK]',
			    'want',
			    '##want',
			    '##ed',
			    'wa',
			    'un',
			    'runn',
			    '##ing',
			    ',',
			    'low',
			    'lowest',
			]
			__lowercase					=    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]      )      )




	def       UpperCAmelCase (	self       :    Optional[int]				,			__lowerCamelCase       :    List[Any]      )					->   Any:

			'''simple docstring'''




			__lowercase					=    'UNwant\u00E9d,running'
			__lowercase					=    'unwanted, running'
			return input_text, output_text




	def       UpperCAmelCase (	self       :    List[str]      )					->   Optional[int]:

			'''simple docstring'''




			__lowercase					=    self.tokenizer_class(self.vocab_file      )

			__lowercase					=    tokenizer.tokenize('UNwant\u00E9d,running'      )
			self.assertListEqual(__lowerCamelCase				,			['un', '##want', '##ed', ',', 'runn', '##ing']      )
			self.assertListEqual(tokenizer.convert_tokens_to_ids(__lowerCamelCase      )				,			[9, 6, 7, 12, 10, 11]      )




	def       UpperCAmelCase (	self       :    Dict      )					->   Tuple:

			'''simple docstring'''




			if not self.test_rust_tokenizer:
					return

			__lowercase					=    self.get_tokenizer()
			__lowercase					=    self.get_rust_tokenizer()

			__lowercase					=    'UNwant\u00E9d,running'

			__lowercase					=    tokenizer.tokenize(__lowerCamelCase      )
			__lowercase					=    rust_tokenizer.tokenize(__lowerCamelCase      )
			self.assertListEqual(__lowerCamelCase				,			__lowerCamelCase      )

			__lowercase					=    tokenizer.encode(__lowerCamelCase				,			add_special_tokens=__lowerCamelCase      )
			__lowercase					=    rust_tokenizer.encode(__lowerCamelCase				,			add_special_tokens=__lowerCamelCase      )
			self.assertListEqual(__lowerCamelCase				,			__lowerCamelCase      )

			__lowercase					=    self.get_rust_tokenizer()
			__lowercase					=    tokenizer.encode(__lowerCamelCase      )
			__lowercase					=    rust_tokenizer.encode(__lowerCamelCase      )
			self.assertListEqual(__lowerCamelCase				,			__lowerCamelCase      )

			# With lower casing
			__lowercase					=    self.get_tokenizer(do_lower_case=__lowerCamelCase      )
			__lowercase					=    self.get_rust_tokenizer(do_lower_case=__lowerCamelCase      )

			__lowercase					=    'UNwant\u00E9d,running'

			__lowercase					=    tokenizer.tokenize(__lowerCamelCase      )
			__lowercase					=    rust_tokenizer.tokenize(__lowerCamelCase      )
			self.assertListEqual(__lowerCamelCase				,			__lowerCamelCase      )

			__lowercase					=    tokenizer.encode(__lowerCamelCase				,			add_special_tokens=__lowerCamelCase      )
			__lowercase					=    rust_tokenizer.encode(__lowerCamelCase				,			add_special_tokens=__lowerCamelCase      )
			self.assertListEqual(__lowerCamelCase				,			__lowerCamelCase      )

			__lowercase					=    self.get_rust_tokenizer()
			__lowercase					=    tokenizer.encode(__lowerCamelCase      )
			__lowercase					=    rust_tokenizer.encode(__lowerCamelCase      )
			self.assertListEqual(__lowerCamelCase				,			__lowerCamelCase      )




	def       UpperCAmelCase (	self       :    Optional[int]      )					->   Optional[Any]:

			'''simple docstring'''




			__lowercase					=    BasicTokenizer()

			self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz'      )				,			['ah', '\u535A', '\u63A8', 'zz']      )




	def       UpperCAmelCase (	self       :    str      )					->   List[str]:

			'''simple docstring'''




			__lowercase					=    BasicTokenizer(do_lower_case=__lowerCamelCase      )

			self.assertListEqual(
			    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '      )				,			['hello', '!', 'how', 'are', 'you', '?']      )
			self.assertListEqual(tokenizer.tokenize('H\u00E9llo'      )				,			['hello']      )




	def       UpperCAmelCase (	self       :    List[str]      )					->   str:

			'''simple docstring'''




			__lowercase					=    BasicTokenizer(do_lower_case=__lowerCamelCase				,			strip_accents=__lowerCamelCase      )

			self.assertListEqual(
			    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '      )				,			['hällo', '!', 'how', 'are', 'you', '?']      )
			self.assertListEqual(tokenizer.tokenize('H\u00E9llo'      )				,			['h\u00E9llo']      )




	def       UpperCAmelCase (	self       :    Dict      )					->   Any:

			'''simple docstring'''




			__lowercase					=    BasicTokenizer(do_lower_case=__lowerCamelCase				,			strip_accents=__lowerCamelCase      )

			self.assertListEqual(
			    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '      )				,			['hallo', '!', 'how', 'are', 'you', '?']      )
			self.assertListEqual(tokenizer.tokenize('H\u00E9llo'      )				,			['hello']      )




	def       UpperCAmelCase (	self       :    str      )					->   str:

			'''simple docstring'''




			__lowercase					=    BasicTokenizer(do_lower_case=__lowerCamelCase      )

			self.assertListEqual(
			    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '      )				,			['hallo', '!', 'how', 'are', 'you', '?']      )
			self.assertListEqual(tokenizer.tokenize('H\u00E9llo'      )				,			['hello']      )




	def       UpperCAmelCase (	self       :    Tuple      )					->   Union[str, Any]:

			'''simple docstring'''




			__lowercase					=    BasicTokenizer(do_lower_case=__lowerCamelCase      )

			self.assertListEqual(
			    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '      )				,			['HeLLo', '!', 'how', 'Are', 'yoU', '?']      )




	def       UpperCAmelCase (	self       :    List[str]      )					->   Optional[int]:

			'''simple docstring'''




			__lowercase					=    BasicTokenizer(do_lower_case=__lowerCamelCase				,			strip_accents=__lowerCamelCase      )

			self.assertListEqual(
			    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '      )				,			['HäLLo', '!', 'how', 'Are', 'yoU', '?']      )




	def       UpperCAmelCase (	self       :    Optional[int]      )					->   str:

			'''simple docstring'''




			__lowercase					=    BasicTokenizer(do_lower_case=__lowerCamelCase				,			strip_accents=__lowerCamelCase      )

			self.assertListEqual(
			    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '      )				,			['HaLLo', '!', 'how', 'Are', 'yoU', '?']      )




	def       UpperCAmelCase (	self       :    List[str]      )					->   Union[str, Any]:

			'''simple docstring'''




			__lowercase					=    BasicTokenizer(do_lower_case=__lowerCamelCase				,			never_split=['[UNK]']      )

			self.assertListEqual(
			    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU? [UNK]'      )				,			['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]']      )




	def       UpperCAmelCase (	self       :    Union[str, Any]      )					->   List[str]:

			'''simple docstring'''




			__lowercase					=    ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing']

			__lowercase					=    {}
			for i, token in enumerate(__lowerCamelCase      ):
					__lowercase					=    i
			__lowercase					=    WordpieceTokenizer(vocab=__lowerCamelCase				,			unk_token='[UNK]'      )

			self.assertListEqual(tokenizer.tokenize(''      )				,			[]      )

			self.assertListEqual(tokenizer.tokenize('unwanted running'      )				,			['un', '##want', '##ed', 'runn', '##ing']      )

			self.assertListEqual(tokenizer.tokenize('unwantedX running'      )				,			['[UNK]', 'runn', '##ing']      )




	def       UpperCAmelCase (	self       :    Tuple      )					->   List[Any]:

			'''simple docstring'''




			self.assertTrue(_is_whitespace(' '      )      )
			self.assertTrue(_is_whitespace('\t'      )      )
			self.assertTrue(_is_whitespace('\r'      )      )
			self.assertTrue(_is_whitespace('\n'      )      )
			self.assertTrue(_is_whitespace('\u00A0'      )      )

			self.assertFalse(_is_whitespace('A'      )      )
			self.assertFalse(_is_whitespace('-'      )      )




	def       UpperCAmelCase (	self       :    Any      )					->   List[Any]:

			'''simple docstring'''




			self.assertTrue(_is_control('\u0005'      )      )

			self.assertFalse(_is_control('A'      )      )
			self.assertFalse(_is_control(' '      )      )
			self.assertFalse(_is_control('\t'      )      )
			self.assertFalse(_is_control('\r'      )      )




	def       UpperCAmelCase (	self       :    Union[str, Any]      )					->   List[str]:

			'''simple docstring'''




			self.assertTrue(_is_punctuation('-'      )      )
			self.assertTrue(_is_punctuation('$'      )      )
			self.assertTrue(_is_punctuation('`'      )      )
			self.assertTrue(_is_punctuation('.'      )      )

			self.assertFalse(_is_punctuation('A'      )      )
			self.assertFalse(_is_punctuation(' '      )      )




	def       UpperCAmelCase (	self       :    List[str]      )					->   Optional[int]:

			'''simple docstring'''




			__lowercase					=    self.get_tokenizer()

			# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
			self.assertListEqual([tokenizer.tokenize(__lowerCamelCase      ) for t in ['Test', '\xad', 'test']]				,			[['[UNK]'], [], ['[UNK]']]      )

			if self.test_rust_tokenizer:
					__lowercase					=    self.get_rust_tokenizer()
					self.assertListEqual(
					    [rust_tokenizer.tokenize(__lowerCamelCase      ) for t in ['Test', '\xad', 'test']]				,			[['[UNK]'], [], ['[UNK]']]      )




	@slow
	def       UpperCAmelCase (	self       :    int      )					->   Optional[Any]:

			'''simple docstring'''




			__lowercase					=    self.tokenizer_class.from_pretrained('bert-base-uncased'      )

			__lowercase					=    tokenizer.encode('sequence builders'				,			add_special_tokens=__lowerCamelCase      )
			__lowercase					=    tokenizer.encode('multi-sequence build'				,			add_special_tokens=__lowerCamelCase      )

			__lowercase					=    tokenizer.build_inputs_with_special_tokens(__lowerCamelCase      )
			__lowercase					=    tokenizer.build_inputs_with_special_tokens(__lowerCamelCase				,			__lowerCamelCase      )

			assert encoded_sentence == [101] + text + [102]
			assert encoded_pair == [101] + text + [102] + text_a + [102]




	def       UpperCAmelCase (	self       :    str      )					->   str:

			'''simple docstring'''




			for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
					with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"      ):
							__lowercase					=    self.rust_tokenizer_class.from_pretrained(__lowerCamelCase				,			**__lowerCamelCase      )

							__lowercase					=    F"A, naïve {tokenizer_r.mask_token} AllenNLP sentence."
							__lowercase					=    tokenizer_r.encode_plus(
							    __lowerCamelCase				,			return_attention_mask=__lowerCamelCase				,			return_token_type_ids=__lowerCamelCase				,			return_offsets_mapping=__lowerCamelCase				,			add_special_tokens=__lowerCamelCase				,			)

							__lowercase					=    tokenizer_r.do_lower_case if hasattr(__lowerCamelCase				,			'do_lower_case'      ) else False
							__lowercase					=    (
							    [
							        ((0, 0), tokenizer_r.cls_token),
							        ((0, 1), 'A'),
							        ((1, 2), ','),
							        ((3, 5), 'na'),
							        ((5, 6), '##ï'),
							        ((6, 8), '##ve'),
							        ((9, 15), tokenizer_r.mask_token),
							        ((16, 21), 'Allen'),
							        ((21, 23), '##NL'),
							        ((23, 24), '##P'),
							        ((25, 33), 'sentence'),
							        ((33, 34), '.'),
							        ((0, 0), tokenizer_r.sep_token),
							    ]
							    if not do_lower_case
							    else [
							        ((0, 0), tokenizer_r.cls_token),
							        ((0, 1), 'a'),
							        ((1, 2), ','),
							        ((3, 8), 'naive'),
							        ((9, 15), tokenizer_r.mask_token),
							        ((16, 21), 'allen'),
							        ((21, 23), '##nl'),
							        ((23, 24), '##p'),
							        ((25, 33), 'sentence'),
							        ((33, 34), '.'),
							        ((0, 0), tokenizer_r.sep_token),
							    ]
							)

							self.assertEqual(
							    [e[1] for e in expected_results]				,			tokenizer_r.convert_ids_to_tokens(tokens['input_ids']      )      )
							self.assertEqual([e[0] for e in expected_results]				,			tokens['offset_mapping']      )






	@slow
	def       UpperCAmelCase (	self       :    Optional[int]      )					->   Dict:

			'''simple docstring'''




			for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
					with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"      ):
							__lowercase					=    self.rust_tokenizer_class.from_pretrained(__lowerCamelCase				,			**__lowerCamelCase      )
							__lowercase					=    self.tokenizer_class.from_pretrained(__lowerCamelCase				,			**__lowerCamelCase      )
							__lowercase					=    [['Hello world!', 'Nice to meet you!'], ['The cute cat.', 'The adorable dog.']]

							__lowercase					=    tokenizer_r.batch_encode_candidates(__lowerCamelCase				,			max_length=10				,			return_tensors='np'      )
							__lowercase					=    tokenizer_p.batch_encode_candidates(__lowerCamelCase				,			max_length=10				,			return_tensors='np'      )

							__lowercase					=    (2, 2, 10)

							self.assertEqual(encoded_sentence_r['input_ids'].shape				,			__lowerCamelCase      )
							self.assertEqual(encoded_sentence_r['attention_mask'].shape				,			__lowerCamelCase      )
							self.assertEqual(encoded_sentence_r['token_type_ids'].shape				,			__lowerCamelCase      )

							self.assertEqual(encoded_sentence_p['input_ids'].shape				,			__lowerCamelCase      )
							self.assertEqual(encoded_sentence_p['attention_mask'].shape				,			__lowerCamelCase      )
							self.assertEqual(encoded_sentence_p['token_type_ids'].shape				,			__lowerCamelCase      )











from math import floor, sqrt



def    SCREAMING_SNAKE_CASE							(			snake_case       )		->						int:
		__lowercase					=    0.0
		__lowercase					=    1.0
		__lowercase					=    int(sqrt(snake_case       )       )
		__lowercase					=    root
		__lowercase					=    0
		while integer_part != 2 * root:
				__lowercase					=    denominator * integer_part - numerator
				__lowercase					=    (n - numerator**2) / denominator
				__lowercase					=    int((root + numerator) / denominator       )
				period += 1
		return period



def    SCREAMING_SNAKE_CASE							(			snake_case = 10_000       )		->						int:
		__lowercase					=    0
		for i in range(2	,      n + 1       ):
				__lowercase					=    sqrt(snake_case       )
				if sr - floor(snake_case       ) != 0 and continuous_fraction_period(snake_case       ) % 2 == 1:
						count_odd_periods += 1
		return count_odd_periods


if __name__ == "__main__":
		print(F"""{solution(int(input().strip()))}""")




