



'''simple docstring'''


from typing import List, Optional, Tuple, Union

from . import logging
from .import_utils import is_torch_available, is_torch_version


if is_torch_available():
  import torch

lowercase											=      logging.get_logger(__name__)  # pylint: disable=invalid-name

try:
  from torch._dynamo import allow_in_graph as maybe_allow_in_graph
except (ImportError, ModuleNotFoundError):






  def 			UpperCAmelCase_							(		cls							):


       '''simple docstring'''







       return cls






def 			UpperCAmelCase_							(		lowercase__							,						lowercase__ = None							,						lowercase__ = None							,						lowercase__ = None							,						lowercase__ = None							,						):


     '''simple docstring'''







     a_									=device
     a_									=shape[0]

     a_									=layout or torch.strided
     a_									=device or torch.device("cpu"							)

     if generator is not None:
          a_									=generator.device.type if not isinstance(lowercase__							,						lowercase__							) else generator[0].device.type
          if gen_device_type != device.type and gen_device_type == "cpu":
               a_									="cpu"
               if device != "mps":
                    logger.info(
                        F"""The passed generator was created on 'cpu' even though a tensor on {device} was expected."""
                        F""" Tensors will be created on 'cpu' and then moved to {device}. Note that one can probably"""
                        F""" slighly speed up this function by passing a generator that was created on the {device} device."""							)
          elif gen_device_type != device.type and gen_device_type == "cuda":
               raise ValueError(F"""Cannot generate a {device} tensor from a generator of type {gen_device_type}."""							)

     if isinstance(lowercase__							,						lowercase__							):
          a_									=(1,) + shape[1:]
          a_									=[
              torch.randn(lowercase__							,						generator=generator[i]							,						device=lowercase__							,						dtype=lowercase__							,						layout=lowercase__							)
              for i in range(lowercase__							)
          ]
          a_									=torch.cat(lowercase__							,						dim=0							).to(lowercase__							)
     else:
          a_									=torch.randn(lowercase__							,						generator=lowercase__							,						device=lowercase__							,						dtype=lowercase__							,						layout=lowercase__							).to(lowercase__							)

     return latents






def 			UpperCAmelCase_							(		lowercase__							):


     '''simple docstring'''







     if is_torch_version("<"							,						"2.0.0"							) or not hasattr(lowercase__							,						"_dynamo"							):
          return False
     return isinstance(lowercase__							,						torch._dynamo.eval_frame.OptimizedModule							)







'''simple docstring'''


from math import floor, sqrt






def 			UpperCAmelCase_							(		lowercase__							):


     '''simple docstring'''







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






def 			UpperCAmelCase_							(		lowercase__ = 1_0_0_0_0							):


     '''simple docstring'''







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


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


