





import os
import pickle
import tempfile
import unittest
from typing import Callable, Optional

import numpy as np

from transformers import (
    BatchEncoding,
    BertTokenizer,
    BertTokenizerFast,
    PreTrainedTokenizer,
    PreTrainedTokenizerFast,
    TensorType,
    TokenSpan,
    is_tokenizers_available,
)
from transformers.models.gpta.tokenization_gpta import GPTaTokenizer
from transformers.testing_utils import CaptureStderr, require_flax, require_tf, require_tokenizers, require_torch, slow


if is_tokenizers_available():
				from tokenizers import Tokenizer
				from tokenizers.models import WordPiece

class 		snake_case_      (       unittest.TestCase	):







	'''simple docstring'''




	def       UpperCAmelCase (	self       :    str				,			__lowerCamelCase       :    Tuple      )					->   Dict:

			'''simple docstring'''




			__lowercase					=    list(tokenizer_class.max_model_input_sizes.keys()      )
			for model_name in sa_models[:1]:
					__lowercase					=    tokenizer_class.from_pretrained(A_      )
					self.assertIsNotNone(A_      )
					self.assertIsInstance(A_				,			A_      )
					self.assertIsInstance(A_				,			A_      )

					for special_tok in tokenizer.all_special_tokens:
							self.assertIsInstance(A_				,			A_      )
							__lowercase					=    tokenizer.convert_tokens_to_ids(A_      )
							self.assertIsInstance(A_				,			A_      )




	def       UpperCAmelCase (	self       :    Any				,			__lowerCamelCase       :    BatchEncoding				,			__lowerCamelCase       :    Optional[Callable] = None      )					->   int:

			'''simple docstring'''




			__lowercase					=    pickle.dumps(A_      )
			self.assertIsNotNone(A_      )

			__lowercase					=    pickle.loads(A_      )

			# Ensure is_fast is correctly restored
			self.assertEqual(be_restored.is_fast				,			be_original.is_fast      )

			# Ensure encodings are potentially correctly restored
			if be_original.is_fast:
					self.assertIsNotNone(be_restored.encodings      )
			else:
					self.assertIsNone(be_restored.encodings      )

			# Ensure the keys are the same
			for original_v, restored_v in zip(be_original.values()				,			be_restored.values()      ):
					if equal_op:
							self.assertTrue(equal_op(A_				,			A_      )      )
					else:
							self.assertEqual(A_				,			A_      )




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

			'''simple docstring'''




			self.check_tokenizer_from_pretrained(A_      )




	def       UpperCAmelCase (	self       :    Any      )					->   int:

			'''simple docstring'''




			self.assertEqual(TensorType('tf'      )				,			TensorType.TENSORFLOW      )
			self.assertEqual(TensorType('pt'      )				,			TensorType.PYTORCH      )
			self.assertEqual(TensorType('np'      )				,			TensorType.NUMPY      )




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

			'''simple docstring'''




			import numpy as np

			__lowercase					=    BertTokenizer.from_pretrained('bert-base-cased'      )
			__lowercase					=    BertTokenizerFast.from_pretrained('bert-base-cased'      )

			# Python no tensor
			with self.subTest('BatchEncoding (Python, return_tensors=None)'      ):
					self.assert_dump_and_restore(tokenizer_p('Small example to encode'      )      )

			with self.subTest('BatchEncoding (Python, return_tensors=NUMPY)'      ):
					self.assert_dump_and_restore(
					    tokenizer_p('Small example to encode'				,			return_tensors=TensorType.NUMPY      )				,			np.array_equal      )

			with self.subTest('BatchEncoding (Rust, return_tensors=None)'      ):
					self.assert_dump_and_restore(tokenizer_r('Small example to encode'      )      )

			with self.subTest('BatchEncoding (Rust, return_tensors=NUMPY)'      ):
					self.assert_dump_and_restore(
					    tokenizer_r('Small example to encode'				,			return_tensors=TensorType.NUMPY      )				,			np.array_equal      )




	@require_tf
	@require_tokenizers
	def       UpperCAmelCase (	self       :    List[Any]      )					->   Optional[int]:

			'''simple docstring'''




			import tensorflow as tf

			def tf_array_equals(__lowerCamelCase       :    Tuple				,			__lowerCamelCase       :    Any      ):
					return tf.reduce_all(tf.equal(A_				,			A_      )      )

			__lowercase					=    BertTokenizer.from_pretrained('bert-base-cased'      )
			__lowercase					=    BertTokenizerFast.from_pretrained('bert-base-cased'      )

			with self.subTest('BatchEncoding (Python, return_tensors=TENSORFLOW)'      ):
					self.assert_dump_and_restore(
					    tokenizer_p('Small example to encode'				,			return_tensors=TensorType.TENSORFLOW      )				,			A_      )

			with self.subTest('BatchEncoding (Rust, return_tensors=TENSORFLOW)'      ):
					self.assert_dump_and_restore(
					    tokenizer_r('Small example to encode'				,			return_tensors=TensorType.TENSORFLOW      )				,			A_      )




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

			'''simple docstring'''




			import torch

			__lowercase					=    BertTokenizer.from_pretrained('bert-base-cased'      )
			__lowercase					=    BertTokenizerFast.from_pretrained('bert-base-cased'      )

			with self.subTest('BatchEncoding (Python, return_tensors=PYTORCH)'      ):
					self.assert_dump_and_restore(
					    tokenizer_p('Small example to encode'				,			return_tensors=TensorType.PYTORCH      )				,			torch.equal      )

			with self.subTest('BatchEncoding (Rust, return_tensors=PYTORCH)'      ):
					self.assert_dump_and_restore(
					    tokenizer_r('Small example to encode'				,			return_tensors=TensorType.PYTORCH      )				,			torch.equal      )




	@require_tokenizers
	def       UpperCAmelCase (	self       :    Dict      )					->   int:

			'''simple docstring'''




			__lowercase					=    BertTokenizer.from_pretrained('bert-base-cased'      )
			__lowercase					=    BertTokenizerFast.from_pretrained('bert-base-cased'      )

			with self.subTest('Python Tokenizer'      ):
					self.assertFalse(tokenizer_p('Small example to_encode'      ).is_fast      )

			with self.subTest('Rust Tokenizer'      ):
					self.assertTrue(tokenizer_r('Small example to_encode'      ).is_fast      )




	@require_tokenizers
	def       UpperCAmelCase (	self       :    Union[str, Any]      )					->   Optional[int]:

			'''simple docstring'''




			__lowercase					=    BertTokenizerFast.from_pretrained('bert-base-cased'      )
			__lowercase					=    tokenizer_r(['Test', '\xad', 'test']				,			is_split_into_words=A_      )

			self.assertEqual(encoded.word_to_tokens(0      )				,			TokenSpan(start=1				,			end=2      )      )
			self.assertEqual(encoded.word_to_tokens(1      )				,			A_      )
			self.assertEqual(encoded.word_to_tokens(2      )				,			TokenSpan(start=2				,			end=3      )      )




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

			'''simple docstring'''




			__lowercase					=    BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}      )
			__lowercase					=    batch.convert_to_tensors(tensor_type='np'      )
			self.assertEqual(tensor_batch['inputs'].shape				,			(2, 3)      )
			self.assertEqual(tensor_batch['labels'].shape				,			(2,)      )
			# test converting the converted
			with CaptureStderr() as cs:
					__lowercase					=    batch.convert_to_tensors(tensor_type='np'      )
			self.assertFalse(len(cs.err      )				,			msg=F"should have no warning, but got {cs.err}"      )

			__lowercase					=    BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}      )
			__lowercase					=    batch.convert_to_tensors(tensor_type='np'				,			prepend_batch_axis=A_      )
			self.assertEqual(tensor_batch['inputs'].shape				,			(1, 3)      )
			self.assertEqual(tensor_batch['labels'].shape				,			(1,)      )




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

			'''simple docstring'''




			__lowercase					=    BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}      )
			__lowercase					=    batch.convert_to_tensors(tensor_type='pt'      )
			self.assertEqual(tensor_batch['inputs'].shape				,			(2, 3)      )
			self.assertEqual(tensor_batch['labels'].shape				,			(2,)      )
			# test converting the converted
			with CaptureStderr() as cs:
					__lowercase					=    batch.convert_to_tensors(tensor_type='pt'      )
			self.assertFalse(len(cs.err      )				,			msg=F"should have no warning, but got {cs.err}"      )

			__lowercase					=    BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}      )
			__lowercase					=    batch.convert_to_tensors(tensor_type='pt'				,			prepend_batch_axis=A_      )
			self.assertEqual(tensor_batch['inputs'].shape				,			(1, 3)      )
			self.assertEqual(tensor_batch['labels'].shape				,			(1,)      )




	@require_tf
	def       UpperCAmelCase (	self       :    str      )					->   Tuple:

			'''simple docstring'''




			__lowercase					=    BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}      )
			__lowercase					=    batch.convert_to_tensors(tensor_type='tf'      )
			self.assertEqual(tensor_batch['inputs'].shape				,			(2, 3)      )
			self.assertEqual(tensor_batch['labels'].shape				,			(2,)      )
			# test converting the converted
			with CaptureStderr() as cs:
					__lowercase					=    batch.convert_to_tensors(tensor_type='tf'      )
			self.assertFalse(len(cs.err      )				,			msg=F"should have no warning, but got {cs.err}"      )

			__lowercase					=    BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}      )
			__lowercase					=    batch.convert_to_tensors(tensor_type='tf'				,			prepend_batch_axis=A_      )
			self.assertEqual(tensor_batch['inputs'].shape				,			(1, 3)      )
			self.assertEqual(tensor_batch['labels'].shape				,			(1,)      )




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

			'''simple docstring'''




			__lowercase					=    BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}      )
			__lowercase					=    batch.convert_to_tensors(tensor_type='jax'      )
			self.assertEqual(tensor_batch['inputs'].shape				,			(2, 3)      )
			self.assertEqual(tensor_batch['labels'].shape				,			(2,)      )
			# test converting the converted
			with CaptureStderr() as cs:
					__lowercase					=    batch.convert_to_tensors(tensor_type='jax'      )
			self.assertFalse(len(cs.err      )				,			msg=F"should have no warning, but got {cs.err}"      )

			__lowercase					=    BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}      )
			__lowercase					=    batch.convert_to_tensors(tensor_type='jax'				,			prepend_batch_axis=A_      )
			self.assertEqual(tensor_batch['inputs'].shape				,			(1, 3)      )
			self.assertEqual(tensor_batch['labels'].shape				,			(1,)      )




	def       UpperCAmelCase (	self       :    Tuple      )					->   int:

			'''simple docstring'''




			__lowercase					=    [{'input_ids': np.array([0, 1, 2]      )}, {'input_ids': np.array([0, 1, 2, 3]      )}]
			__lowercase					=    BertTokenizer.from_pretrained('bert-base-cased'      )

			__lowercase					=    tokenizer.pad(A_				,			padding=A_      )
			self.assertTrue(isinstance(batch['input_ids']				,			np.ndarray      )      )
			self.assertEqual(batch['input_ids'].tolist()				,			[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]      )
			__lowercase					=    tokenizer.pad(A_				,			padding=A_				,			return_tensors='np'      )
			self.assertTrue(isinstance(batch['input_ids']				,			np.ndarray      )      )
			self.assertEqual(batch['input_ids'].tolist()				,			[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]      )




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

			'''simple docstring'''




			import torch

			__lowercase					=    [{'input_ids': torch.tensor([0, 1, 2]      )}, {'input_ids': torch.tensor([0, 1, 2, 3]      )}]
			__lowercase					=    BertTokenizer.from_pretrained('bert-base-cased'      )

			__lowercase					=    tokenizer.pad(A_				,			padding=A_      )
			self.assertTrue(isinstance(batch['input_ids']				,			torch.Tensor      )      )
			self.assertEqual(batch['input_ids'].tolist()				,			[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]      )
			__lowercase					=    tokenizer.pad(A_				,			padding=A_				,			return_tensors='pt'      )
			self.assertTrue(isinstance(batch['input_ids']				,			torch.Tensor      )      )
			self.assertEqual(batch['input_ids'].tolist()				,			[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]      )




	@require_tf
	def       UpperCAmelCase (	self       :    str      )					->   Dict:

			'''simple docstring'''




			import tensorflow as tf

			__lowercase					=    [{'input_ids': tf.constant([0, 1, 2]      )}, {'input_ids': tf.constant([0, 1, 2, 3]      )}]
			__lowercase					=    BertTokenizer.from_pretrained('bert-base-cased'      )

			__lowercase					=    tokenizer.pad(A_				,			padding=A_      )
			self.assertTrue(isinstance(batch['input_ids']				,			tf.Tensor      )      )
			self.assertEqual(batch['input_ids'].numpy().tolist()				,			[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]      )
			__lowercase					=    tokenizer.pad(A_				,			padding=A_				,			return_tensors='tf'      )
			self.assertTrue(isinstance(batch['input_ids']				,			tf.Tensor      )      )
			self.assertEqual(batch['input_ids'].numpy().tolist()				,			[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]      )




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

			'''simple docstring'''




			__lowercase					=    Tokenizer(WordPiece(unk_token='[UNK]'      )      )
			PreTrainedTokenizerFast(tokenizer_object=A_      )






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

			'''simple docstring'''




			__lowercase					=    Tokenizer(WordPiece(unk_token='[UNK]'      )      )
			with tempfile.TemporaryDirectory() as tmpdirname:
					bert_tokenizer.save(os.path.join(A_				,			'tokenizer.json'      )      )
					PreTrainedTokenizerFast(tokenizer_file=os.path.join(A_				,			'tokenizer.json'      )      )











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()))}""")




