from math import floor, sqrt




def   _UpperCamelCase   (			snake_case__							)						->   str:
							__UpperCAmelCase						:			Optional[int]         =   0.0
							__UpperCAmelCase						:			List[Any]         =   1.0
							__UpperCAmelCase						:			Union[str, Any]         =   int(sqrt(snake_case__							)							)
							__UpperCAmelCase						:			Dict         =   root
							__UpperCAmelCase						:			Optional[int]         =   0
							while integer_part != 2 * root:
														__UpperCAmelCase						:			List[Any]         =   denominator * integer_part - numerator
														__UpperCAmelCase						:			str         =   (n - numerator**2) / denominator
														__UpperCAmelCase						:			Union[str, Any]         =   int((root + numerator) / denominator							)
														period += 1
							return period




def   _UpperCamelCase   (			snake_case__ = 1_0000							)						->   List[str]:
							__UpperCAmelCase						:			Optional[int]         =   0
							for i in range(2,    n + 1							):
														__UpperCAmelCase						:			str         =   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()))}')





import unittest
from dataclasses import dataclass
from typing import Optional

from transformers.utils import ModelOutput




@dataclass
class 					_snake_case						(						_lowercase				):
					lowerCamelCase__:		float
					lowerCamelCase__:		Optional[float]  =     None
					lowerCamelCase__:		Optional[float]  =     None




class 					_snake_case						(						unittest.TestCase				):
					def    _lowerCamelCase (  self:				Union[str, Any]     )    ->				List[Any]:
												__UpperCAmelCase						:			str         =   ModelOutputTest(a=30     )
												self.assertEqual(x.a	,  30     )
												self.assertIsNone(x.b     )
												self.assertIsNone(x.c     )
												with self.assertRaises(__lowerCamelCase     ):
																			__UpperCAmelCase						:			List[Any]         =   x.d
					def    _lowerCamelCase (  self:				Optional[int]     )    ->				str:
												__UpperCAmelCase						:			Union[str, Any]         =   ModelOutputTest(a=30	,  b=10     )
												self.assertEqual(x[0]	,  30     )
												self.assertEqual(x[1]	,  10     )
												self.assertEqual(x[:2]	,  (30, 10)     )
												self.assertEqual(x[:]	,  (30, 10)     )

												__UpperCAmelCase						:			Optional[Any]         =   ModelOutputTest(a=30	,  c=10     )
												self.assertEqual(x[0]	,  30     )
												self.assertEqual(x[1]	,  10     )
												self.assertEqual(x[:2]	,  (30, 10)     )
												self.assertEqual(x[:]	,  (30, 10)     )
					def    _lowerCamelCase (  self:				Tuple     )    ->				List[str]:
												__UpperCAmelCase						:			str         =   ModelOutputTest(a=30	,  b=10     )
												self.assertEqual(x["a"]	,  30     )
												self.assertEqual(x["b"]	,  10     )
												with self.assertRaises(__lowerCamelCase     ):
																			__UpperCAmelCase						:			Dict         =   x["c"]

												__UpperCAmelCase						:			Tuple         =   ModelOutputTest(a=30	,  c=10     )
												self.assertEqual(x["a"]	,  30     )
												self.assertEqual(x["c"]	,  10     )
												with self.assertRaises(__lowerCamelCase     ):
																			__UpperCAmelCase						:			Optional[Any]         =   x["b"]
					def    _lowerCamelCase (  self:				str     )    ->				Any:
												__UpperCAmelCase						:			Union[str, Any]         =   ModelOutputTest(a=30     )
												self.assertEqual(list(x.keys()     )	,  ["a"]     )
												self.assertEqual(list(x.values()     )	,  [30]     )
												self.assertEqual(list(x.items()     )	,  [("a", 30)]     )
												self.assertEqual(list(__lowerCamelCase     )	,  ["a"]     )

												__UpperCAmelCase						:			str         =   ModelOutputTest(a=30	,  b=10     )
												self.assertEqual(list(x.keys()     )	,  ["a", "b"]     )
												self.assertEqual(list(x.values()     )	,  [30, 10]     )
												self.assertEqual(list(x.items()     )	,  [("a", 30), ("b", 10)]     )
												self.assertEqual(list(__lowerCamelCase     )	,  ["a", "b"]     )

												__UpperCAmelCase						:			Any         =   ModelOutputTest(a=30	,  c=10     )
												self.assertEqual(list(x.keys()     )	,  ["a", "c"]     )
												self.assertEqual(list(x.values()     )	,  [30, 10]     )
												self.assertEqual(list(x.items()     )	,  [("a", 30), ("c", 10)]     )
												self.assertEqual(list(__lowerCamelCase     )	,  ["a", "c"]     )

												with self.assertRaises(__lowerCamelCase     ):
																			__UpperCAmelCase						:			Dict         =   x.update({"d": 20}     )
												with self.assertRaises(__lowerCamelCase     ):
																			del x["a"]
												with self.assertRaises(__lowerCamelCase     ):
																			__UpperCAmelCase						:			List[Any]         =   x.pop("a"     )
												with self.assertRaises(__lowerCamelCase     ):
																			__UpperCAmelCase						:			str         =   x.setdefault("d"	,  32     )
					def    _lowerCamelCase (  self:				List[str]     )    ->				str:
												__UpperCAmelCase						:			Optional[Any]         =   ModelOutputTest(a=30     )
												__UpperCAmelCase						:			Tuple         =   10
												self.assertEqual(x.a	,  10     )
												self.assertEqual(x["a"]	,  10     )
					def    _lowerCamelCase (  self:				Optional[int]     )    ->				Dict:
												__UpperCAmelCase						:			str         =   ModelOutputTest(a=30     )
												__UpperCAmelCase						:			Optional[int]         =   10
												self.assertEqual(x.a	,  10     )
												self.assertEqual(x["a"]	,  10     )
					def    _lowerCamelCase (  self:				List[Any]     )    ->				Optional[int]:
												__UpperCAmelCase						:			Tuple         =   ModelOutputTest({"a": 30, "b": 10}     )
												self.assertEqual(list(x.keys()     )	,  ["a", "b"]     )
												self.assertEqual(x.a	,  30     )
												self.assertEqual(x.b	,  10     )





					def    _lowerCamelCase (  self:				Optional[int]     )    ->				Union[str, Any]:
												__UpperCAmelCase						:			Dict         =   ModelOutputTest([("a", 30), ("b", 10)]     )
												self.assertEqual(list(x.keys()     )	,  ["a", "b"]     )
												self.assertEqual(x.a	,  30     )
												self.assertEqual(x.b	,  10     )

												with self.assertRaises(__lowerCamelCase     ):
																			__UpperCAmelCase						:			Any         =   ModelOutputTest([("a", 30), (10, 10)]     )

												__UpperCAmelCase						:			Dict         =   ModelOutputTest(a=(30, 30)     )
												self.assertEqual(list(x.keys()     )	,  ["a"]     )
												self.assertEqual(x.a	,  (30, 30)     )




