import os
import tempfile
from pathlib import Path
from unittest import TestCase

import pyarrow as pa
import pytest

from datasets.arrow_dataset import Dataset
from datasets.arrow_reader import ArrowReader, BaseReader, FileInstructions, ReadInstruction, make_file_instructions
from datasets.info import DatasetInfo
from datasets.splits import NamedSplit, Split, SplitDict, SplitInfo

from .utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases







class 			SCREAMING_SNAKE_CASE__ (   SCREAMING_SNAKE_CASE_  ):

       def        snake_case__  (				self :			Optional[int]       ,       _lowerCAmelCase :			int       ,       _lowerCAmelCase :			Any=False       ):
           __snake_case       ,      __snake_case       ,      __snake_case    :							Union[str, Any]             =  (
               filename_skip_take["""filename"""],
               filename_skip_take["""skip"""] if """skip""" in filename_skip_take else None,
               filename_skip_take["""take"""] if """take""" in filename_skip_take else None,
           )
           open(os.path.join(lowercase_       )       ,       """wb"""       ).close()
           __snake_case    :							Dict             =  pa.Table.from_pydict({"""filename""": [Path(lowercase_       ).name] * 1_00}       )
           if take == -1:
               __snake_case    :							Optional[Any]             =  len(lowercase_       ) - skip
           if skip is not None and take is not None:
               __snake_case    :							Optional[Any]             =  pa_table.slice(lowercase_       ,       lowercase_       )
           return pa_table







class 			SCREAMING_SNAKE_CASE__ (   SCREAMING_SNAKE_CASE_  ):

       def        snake_case__  (				self :			Any       ):
           __snake_case    :							Optional[Any]             =  """my_name"""
           __snake_case    :							List[str]             =  SplitInfo(name="""train"""       ,       num_examples=1_00       )
           __snake_case    :							str             =  SplitInfo(name="""test"""       ,       num_examples=1_00       )
           __snake_case    :							Any             =  [train_info, test_info]
           __snake_case    :							List[str]             =  SplitDict()
           split_dict.add(lowercase_       )
           split_dict.add(lowercase_       )
           __snake_case    :							Optional[Any]             =  DatasetInfo(splits=lowercase_       )

           with tempfile.TemporaryDirectory() as tmp_dir:
               __snake_case    :							Optional[int]             =  ReaderTest(lowercase_       ,       lowercase_       )

               __snake_case    :							Tuple             =  """test[:33%]"""
               __snake_case    :							List[Any]             =  Dataset(**reader.read(lowercase_       ,       lowercase_       ,       lowercase_       )       )
               self.assertEqual(dset["""filename"""][0]       ,       f'''{name}-test'''       )
               self.assertEqual(dset.num_rows       ,       33       )
               self.assertEqual(dset.num_columns       ,       1       )

               __snake_case    :							Union[str, Any]             =  ["""train""", """test[:33%]"""]
               __snake_case    :							Union[str, Any]             =  [Split.TRAIN, ReadInstruction.from_spec("""test[:33%]"""       )]
               for instructions in [instructionsa, instructionsa]:
                   __snake_case    :							Optional[int]             =  [reader.read(lowercase_       ,       lowercase_       ,       lowercase_       ) for instr in instructions]
                   __snake_case       ,      __snake_case    :							Optional[int]             =  (Dataset(**lowercase_       ) for dataset_kwargs in datasets_kwargs)
                   self.assertEqual(train_dset["""filename"""][0]       ,       f'''{name}-train'''       )
                   self.assertEqual(train_dset.num_rows       ,       1_00       )
                   self.assertEqual(train_dset.num_columns       ,       1       )
                   self.assertIsInstance(train_dset.split       ,       lowercase_       )
                   self.assertEqual(str(train_dset.split       )       ,       """train"""       )
                   self.assertEqual(test_dset["""filename"""][0]       ,       f'''{name}-test'''       )
                   self.assertEqual(test_dset.num_rows       ,       33       )
                   self.assertEqual(test_dset.num_columns       ,       1       )
                   self.assertIsInstance(test_dset.split       ,       lowercase_       )
                   self.assertEqual(str(test_dset.split       )       ,       """test[:33%]"""       )
                   del train_dset, test_dset

       def        snake_case__  (				self :			Optional[int]       ):
           __snake_case    :							Optional[Any]             =  """my_name"""
           __snake_case    :							str             =  SplitInfo(name="""train"""       ,       num_examples=10_00       ,       shard_lengths=[1_00] * 10       )
           __snake_case    :							Union[str, Any]             =  [train_info]
           __snake_case    :							str             =  SplitDict()
           split_dict.add(lowercase_       )
           __snake_case    :							Optional[Any]             =  DatasetInfo(splits=lowercase_       )

           with tempfile.TemporaryDirectory() as tmp_dir:
               __snake_case    :							Dict             =  ReaderTest(lowercase_       ,       lowercase_       )

               __snake_case    :							int             =  """train[:33%]"""
               __snake_case    :							int             =  Dataset(**reader.read(lowercase_       ,       lowercase_       ,       lowercase_       )       )
               self.assertEqual(dset["""filename"""][0]       ,       f'''{name}-train-00000-of-00010'''       )
               self.assertEqual(dset["""filename"""][-1]       ,       f'''{name}-train-00003-of-00010'''       )
               self.assertEqual(dset.num_rows       ,       3_30       )
               self.assertEqual(dset.num_columns       ,       1       )





       def        snake_case__  (				self :			int       ):
           __snake_case    :							str             =  SplitInfo(name="""train"""       ,       num_examples=1_00       )
           __snake_case    :							List[Any]             =  SplitInfo(name="""test"""       ,       num_examples=1_00       )
           __snake_case    :							List[str]             =  SplitDict()
           split_dict.add(lowercase_       )
           split_dict.add(lowercase_       )
           __snake_case    :							Optional[int]             =  DatasetInfo(splits=lowercase_       )

           with tempfile.TemporaryDirectory() as tmp_dir:
               __snake_case    :							str             =  ReaderTest(lowercase_       ,       lowercase_       )

               __snake_case    :							List[Any]             =  [
                   {"""filename""": os.path.join(lowercase_       ,       """train"""       )},
                   {"""filename""": os.path.join(lowercase_       ,       """test"""       ), """skip""": 10, """take""": 10},
               ]
               __snake_case    :							Optional[int]             =  Dataset(**reader.read_files(lowercase_       ,       original_instructions="""train+test[10:20]"""       )       )
               self.assertEqual(dset.num_rows       ,       1_10       )
               self.assertEqual(dset.num_columns       ,       1       )
               del dset







@pytest.mark.parametrize("""in_memory"""						,				[False, True]					)
def  __lowerCAmelCase							(						__SCREAMING_SNAKE_CASE    : List[str]						,				__SCREAMING_SNAKE_CASE    : Any						,				__SCREAMING_SNAKE_CASE    : Union[str, Any]					):







    '''simple docstring'''
    __snake_case    :							Tuple             =  arrow_file
    with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase():
        __snake_case    :							Tuple             =  ArrowReader.read_table(__SCREAMING_SNAKE_CASE						,				in_memory=__SCREAMING_SNAKE_CASE					)
    assert table.shape == dataset.data.shape
    assert set(table.column_names					) == set(dataset.data.column_names					)
    assert dict(table.to_pydict()					) == dict(dataset.data.to_pydict()					)  # to_pydict returns OrderedDict







@pytest.mark.parametrize("""in_memory"""						,				[False, True]					)
def  __lowerCAmelCase							(						__SCREAMING_SNAKE_CASE    : int						,				__SCREAMING_SNAKE_CASE    : Any						,				__SCREAMING_SNAKE_CASE    : Optional[int]					):







    '''simple docstring'''
    __snake_case    :							List[Any]             =  arrow_file
    __snake_case    :							Optional[int]             =  ArrowReader(""""""						,				__SCREAMING_SNAKE_CASE					)
    with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase():
        __snake_case    :							int             =  reader.read_files([{"""filename""": filename}]						,				in_memory=__SCREAMING_SNAKE_CASE					)
    assert dataset_kwargs.keys() == {"arrow_table", "info", "split"}
    __snake_case    :							Any             =  dataset_kwargs["""arrow_table"""]
    assert table.shape == dataset.data.shape
    assert set(table.column_names					) == set(dataset.data.column_names					)
    assert dict(table.to_pydict()					) == dict(dataset.data.to_pydict()					)  # to_pydict returns OrderedDict







def  __lowerCAmelCase							(						):







    '''simple docstring'''
    assert ReadInstruction("""train"""						,				to=1_0						,				unit="""abs"""					).to_spec() == "train[:10]"
    assert ReadInstruction("""train"""						,				from_=-8_0						,				to=1_0						,				unit="""%"""					).to_spec() == "train[-80%:10%]"

    __snake_case    :							List[str]             =  """train+test"""
    assert ReadInstruction.from_spec(__SCREAMING_SNAKE_CASE					).to_spec() == spec_train_test

    __snake_case    :							Union[str, Any]             =  """train[2:10]"""
    assert ReadInstruction.from_spec(__SCREAMING_SNAKE_CASE					).to_spec() == spec_train_abs

    __snake_case    :							Dict             =  """train[15%:-20%]"""
    assert ReadInstruction.from_spec(__SCREAMING_SNAKE_CASE					).to_spec() == spec_train_pct

    __snake_case    :							List[str]             =  """train[:10%](closest)"""
    assert ReadInstruction.from_spec(__SCREAMING_SNAKE_CASE					).to_spec() == "train[:10%]"

    __snake_case    :							str             =  """train[:10%](pct1_dropremainder)"""
    assert ReadInstruction.from_spec(__SCREAMING_SNAKE_CASE					).to_spec() == spec_train_pct_rounding

    __snake_case    :							Optional[Any]             =  """train[:10%](pct1_dropremainder)+test[-10%:](pct1_dropremainder)"""
    assert ReadInstruction.from_spec(__SCREAMING_SNAKE_CASE					).to_spec() == spec_train_test_pct_rounding







def  __lowerCAmelCase							(						):







    '''simple docstring'''
    __snake_case    :							Optional[int]             =  """dummy"""
    __snake_case    :							Optional[Any]             =  [SplitInfo(name="""train"""						,				num_examples=1_0_0					)]
    __snake_case    :							List[str]             =  """train[:33%]"""
    __snake_case    :							List[Any]             =  """arrow"""
    __snake_case    :							str             =  """prefix"""

    __snake_case    :							Union[str, Any]             =  make_file_instructions(__SCREAMING_SNAKE_CASE						,				__SCREAMING_SNAKE_CASE						,				__SCREAMING_SNAKE_CASE						,				__SCREAMING_SNAKE_CASE						,				__SCREAMING_SNAKE_CASE					)
    assert isinstance(__SCREAMING_SNAKE_CASE						,				__SCREAMING_SNAKE_CASE					)
    assert file_instructions.num_examples == 3_3
    assert file_instructions.file_instructions == [
        {"filename": os.path.join(__SCREAMING_SNAKE_CASE						,				F'''{name}-train.arrow'''					), "skip": 0, "take": 3_3}
    ]

    __snake_case    :							Optional[Any]             =  [SplitInfo(name="""train"""						,				num_examples=1_0_0						,				shard_lengths=[1_0] * 1_0					)]
    __snake_case    :							Union[str, Any]             =  make_file_instructions(__SCREAMING_SNAKE_CASE						,				__SCREAMING_SNAKE_CASE						,				__SCREAMING_SNAKE_CASE						,				__SCREAMING_SNAKE_CASE						,				__SCREAMING_SNAKE_CASE					)
    assert isinstance(__SCREAMING_SNAKE_CASE						,				__SCREAMING_SNAKE_CASE					)
    assert file_instructions.num_examples == 3_3
    assert file_instructions.file_instructions == [
        {"filename": os.path.join(__SCREAMING_SNAKE_CASE						,				F'''{name}-train-00000-of-00010.arrow'''					), "skip": 0, "take": -1},
        {"filename": os.path.join(__SCREAMING_SNAKE_CASE						,				F'''{name}-train-00001-of-00010.arrow'''					), "skip": 0, "take": -1},
        {"filename": os.path.join(__SCREAMING_SNAKE_CASE						,				F'''{name}-train-00002-of-00010.arrow'''					), "skip": 0, "take": -1},
        {"filename": os.path.join(__SCREAMING_SNAKE_CASE						,				F'''{name}-train-00003-of-00010.arrow'''					), "skip": 0, "take": 3},
    ]







@pytest.mark.parametrize("""name, expected_exception"""						,				[(None, TypeError), ("""""", ValueError)]					)
def  __lowerCAmelCase							(						__SCREAMING_SNAKE_CASE    : Tuple						,				__SCREAMING_SNAKE_CASE    : str					):







    '''simple docstring'''
    __snake_case    :							str             =  [SplitInfo(name="""train"""						,				num_examples=1_0_0					)]
    __snake_case    :							Any             =  """train"""
    __snake_case    :							Union[str, Any]             =  """arrow"""
    __snake_case    :							Optional[Any]             =  """prefix_path"""
    with pytest.raises(__SCREAMING_SNAKE_CASE					):
        __snake_case    :							Dict             =  make_file_instructions(__SCREAMING_SNAKE_CASE						,				__SCREAMING_SNAKE_CASE						,				__SCREAMING_SNAKE_CASE						,				__SCREAMING_SNAKE_CASE						,				__SCREAMING_SNAKE_CASE					)





"""simple docstring"""

from math import floor, sqrt




def 			lowercase__  (    lowerCAmelCase :    int       )       ->					int:






    """simple docstring"""




    UpperCAmelCase  	=    0.0
    UpperCAmelCase  	=    1.0
    UpperCAmelCase  	=    int(sqrt(lowerCAmelCase       )       )
    UpperCAmelCase  	=    root
    UpperCAmelCase  	=    0
    while integer_part != 2 * root:
        UpperCAmelCase  	=    denominator * integer_part - numerator
        UpperCAmelCase  	=    (n - numerator**2) / denominator
        UpperCAmelCase  	=    int((root + numerator) / denominator       )
        period += 1
    return period




def 			lowercase__  (    lowerCAmelCase :    int = 10_000       )       ->					int:






    """simple docstring"""




    UpperCAmelCase  	=    0
    for i in range(2       , n + 1       ):
        UpperCAmelCase  	=    sqrt(lowerCAmelCase       )
        if sr - floor(lowerCAmelCase       ) != 0 and continuous_fraction_period(lowerCAmelCase       ) % 2 == 1:
            count_odd_periods += 1
    return count_odd_periods


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



