


'''simple docstring'''






from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_torch_available, is_torch_tpu_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_torch_available():
  import torch

if is_torch_tpu_available(check_device=False):
  import torch_xla.core.xla_model as xm


__A					:  Optional[int]											=      logging.get_logger(__name__)






@dataclass
class    __snake_case       (   _SCREAMING_SNAKE_CASE):







    """simple docstring"""



    lowercase    =					[
        'no_inference',
        'no_cuda',
        'no_tpu',
        'no_speed',
        'no_memory',
        'no_env_print',
        'no_multi_process',
    ]

    def __init__(   self    :  List[str]    ,						**lowerCamelCase    :  List[str]		)   ->  List[Any]:
      for deprecated_arg in self.deprecated_args:
        if deprecated_arg in kwargs:
          lowerCAmelCase_			:      List[Any]			=   deprecated_arg[3:]
          setattr(self    ,						lowerCamelCase    ,						not kwargs.pop(lowerCamelCase		)		)
          logger.warning(
              F'{deprecated_arg} is depreciated. Please use --no_{positive_arg} or'
              F' {positive_arg}={kwargs[positive_arg]}'		)

      lowerCAmelCase_			:      Optional[int]			=   kwargs.pop("""torchscript"""    ,						self.torchscript		)
      lowerCAmelCase_			:      Tuple			=   kwargs.pop("""torch_xla_tpu_print_metrics"""    ,						self.torch_xla_tpu_print_metrics		)
      lowerCAmelCase_			:      str			=   kwargs.pop("""fp16_opt_level"""    ,						self.fpaa_opt_level		)
      super().__init__(**lowerCamelCase		)

    lowercase    =					field(default=_SCREAMING_SNAKE_CASE	,metadata={'help': 'Trace the models using torchscript'})
    lowercase    =					field(default=_SCREAMING_SNAKE_CASE	,metadata={'help': 'Print Xla/PyTorch tpu metrics'})
    lowercase    =					field(
        default='O1'	,metadata={
            'help': (
                'For fp16: Apex AMP optimization level selected in [\'O0\', \'O1\', \'O2\', and \'O3\']. '
                'See details at https://nvidia.github.io/apex/amp.html'
            )
        }	,)

    @cached_property
    def __lowercase   (   self    :  List[Any]		)   ->  Tuple["torch.device", int]:
      requires_backends(self    ,						["""torch"""]		)
      logger.info("""PyTorch: setting up devices"""		)
      if not self.cuda:
        lowerCAmelCase_			:      List[Any]			=   torch.device("""cpu"""		)
        lowerCAmelCase_			:      str			=   0
      elif is_torch_tpu_available():
        lowerCAmelCase_			:      List[Any]			=   xm.xla_device()
        lowerCAmelCase_			:      Optional[int]			=   0
      else:
        lowerCAmelCase_			:      Union[str, Any]			=   torch.device("""cuda""" if torch.cuda.is_available() else """cpu"""		)
        lowerCAmelCase_			:      Union[str, Any]			=   torch.cuda.device_count()
      return device, n_gpu

    @property
    def __lowercase   (   self    :  List[Any]		)   ->  Union[str, Any]:
      return is_torch_tpu_available() and self.tpu

    @property
    def __lowercase   (   self    :  Optional[Any]		)   ->  int:
      requires_backends(self    ,						["""torch"""]		)
      # TODO(PVP): currently only single GPU is supported
      return torch.cuda.current_device()

    @property
    def __lowercase   (   self    :  Union[str, Any]		)   ->  "torch.device":
      requires_backends(self    ,						["""torch"""]		)
      return self._setup_devices[0]

    @property
    def __lowercase   (   self    :  List[str]		)   ->  List[str]:
      requires_backends(self    ,						["""torch"""]		)
      return self._setup_devices[1]





    @property
    def __lowercase   (   self    :  List[Any]		)   ->  str:
      return self.n_gpu > 0







'''simple docstring'''






def 				UpperCamelCase_			(    A__					:   int = 1_00					):
  '''simple docstring'''





  lowerCAmelCase_			:      int			=   set()

  lowerCAmelCase_			:      Tuple			=   0

  lowerCAmelCase_			:      str			=   n + 1  # maximum limit

  for a in range(2							,    A__					):
    for b in range(2							,    A__					):
      lowerCAmelCase_			:      str			=   a**b  # calculates the current power
      collect_powers.add(A__					)  # adds the result to the set
  return len(A__					)


if __name__ == "__main__":
  print("Number of terms ", solution(int(str(input()).strip())))



