


import os
import tempfile
import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch


if is_torch_available():
   import torch
   from torch import nn

   from transformers import (
       Adafactor,
       AdamW,
       get_constant_schedule,
       get_constant_schedule_with_warmup,
       get_cosine_schedule_with_warmup,
       get_cosine_with_hard_restarts_schedule_with_warmup,
       get_inverse_sqrt_schedule,
       get_linear_schedule_with_warmup,
       get_polynomial_decay_schedule_with_warmup,
   )







def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase							,   __lowerCAmelCase=10				)    ->				List[str]:
  snake_case__						= []
  for _ in range(__lowerCAmelCase				):
    lrs.append(scheduler.get_lr()[0]				)
    scheduler.step()
  return lrs







def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase							,   __lowerCAmelCase=10				)    ->				Dict:
  snake_case__						= []
  for step in range(__lowerCAmelCase				):
    lrs.append(scheduler.get_lr()[0]				)
    scheduler.step()
    if step == num_steps // 2:
      with tempfile.TemporaryDirectory() as tmpdirname:
        snake_case__						= os.path.join(__lowerCAmelCase							,   '''schedule.bin'''				)
        torch.save(scheduler.state_dict()							,   __lowerCAmelCase				)

        snake_case__						= torch.load(__lowerCAmelCase				)
        scheduler.load_state_dict(__lowerCAmelCase				)
  return lrs
@require_torch
class 		__magic_name__						(unittest.TestCase				):





     '''simple docstring'''



     def 	SCREAMING_SNAKE_CASE__						(					self:int     ,		_a:List[Any]     ,		_a:Optional[Any]     ,		_a:int   ):
       self.assertEqual(len(_a   )     ,		len(_a   )   )
       for a, b in zip(_a     ,		_a   ):
         self.assertAlmostEqual(_a     ,		_a     ,		delta=_a   )

     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[Any]   ):
       snake_case__						= torch.tensor([0.1, -0.2, -0.1]     ,		requires_grad=_a   )
       snake_case__						= torch.tensor([0.4, 0.2, -0.5]   )
       snake_case__						= nn.MSELoss()
       # No warmup, constant schedule, no gradient clipping
       snake_case__						= AdamW(params=[w]     ,		lr=2e-1     ,		weight_decay=0.0   )
       for _ in range(1_00   ):
         snake_case__						= criterion(_a     ,		_a   )
         loss.backward()
         optimizer.step()
         w.grad.detach_()  # No zero_grad() function on simple tensors. we do it ourselves.
         w.grad.zero_()
       self.assertListAlmostEqual(w.tolist()     ,		[0.4, 0.2, -0.5]     ,		tol=1e-2   )







     def 	SCREAMING_SNAKE_CASE__						(					self:Any   ):
       snake_case__						= torch.tensor([0.1, -0.2, -0.1]     ,		requires_grad=_a   )
       snake_case__						= torch.tensor([0.4, 0.2, -0.5]   )
       snake_case__						= nn.MSELoss()
       # No warmup, constant schedule, no gradient clipping
       snake_case__						= Adafactor(
           params=[w]     ,		lr=1e-2     ,		eps=(1e-30, 1e-3)     ,		clip_threshold=1.0     ,		decay_rate=-0.8     ,		betaa=_a     ,		weight_decay=0.0     ,		relative_step=_a     ,		scale_parameter=_a     ,		warmup_init=_a     ,		)
       for _ in range(10_00   ):
         snake_case__						= criterion(_a     ,		_a   )
         loss.backward()
         optimizer.step()
         w.grad.detach_()  # No zero_grad() function on simple tensors. we do it ourselves.
         w.grad.zero_()
       self.assertListAlmostEqual(w.tolist()     ,		[0.4, 0.2, -0.5]     ,		tol=1e-2   )




@require_torch
class 		__magic_name__						(unittest.TestCase				):





     '''simple docstring'''



     __lowercase				:							int	   =       nn.Linear(50   ,50				) if is_torch_available() else None
     __lowercase				:							Optional[Any]	   =       AdamW(m.parameters()   ,lr=10.0				) if is_torch_available() else None
     __lowercase				:							List[str]	   =       10

     def 	SCREAMING_SNAKE_CASE__						(					self:List[str]     ,		_a:Optional[int]     ,		_a:Optional[int]     ,		_a:Union[str, Any]     ,		_a:int=None   ):
       self.assertEqual(len(_a   )     ,		len(_a   )   )
       for a, b in zip(_a     ,		_a   ):
         self.assertAlmostEqual(_a     ,		_a     ,		delta=_a     ,		msg=_a   )







     def 	SCREAMING_SNAKE_CASE__						(					self:int   ):
       snake_case__						= {'''num_warmup_steps''': 2, '''num_training_steps''': 10}
       # schedulers doct format
       # function: (sched_args_dict, expected_learning_rates)
       snake_case__						= {
           get_constant_schedule: ({}, [10.0] * self.num_steps),
           get_constant_schedule_with_warmup: (
               {'''num_warmup_steps''': 4},
               [0.0, 2.5, 5.0, 7.5, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0],
           ),
           get_linear_schedule_with_warmup: (
               {**common_kwargs},
               [0.0, 5.0, 10.0, 8.75, 7.5, 6.25, 5.0, 3.75, 2.5, 1.25],
           ),
           get_cosine_schedule_with_warmup: (
               {**common_kwargs},
               [0.0, 5.0, 10.0, 9.61, 8.53, 6.91, 5.0, 3.08, 1.46, 0.38],
           ),
           get_cosine_with_hard_restarts_schedule_with_warmup: (
               {**common_kwargs, '''num_cycles''': 2},
               [0.0, 5.0, 10.0, 8.53, 5.0, 1.46, 10.0, 8.53, 5.0, 1.46],
           ),
           get_polynomial_decay_schedule_with_warmup: (
               {**common_kwargs, '''power''': 2.0, '''lr_end''': 1e-7},
               [0.0, 5.0, 10.0, 7.656, 5.625, 3.906, 2.5, 1.406, 0.625, 0.156],
           ),
           get_inverse_sqrt_schedule: (
               {'''num_warmup_steps''': 2},
               [0.0, 5.0, 10.0, 8.165, 7.071, 6.325, 5.774, 5.345, 5.0, 4.714],
           ),
       }

       for scheduler_func, data in scheds.items():
         snake_case__				,				snake_case__						= data

         snake_case__						= scheduler_func(self.optimizer     ,		**_a   )
         self.assertEqual(len([scheduler.get_lr()[0]]   )     ,		1   )
         snake_case__						= unwrap_schedule(_a     ,		self.num_steps   )
         self.assertListAlmostEqual(
             _a     ,		_a     ,		tol=1e-2     ,		msg=F"""failed for {scheduler_func} in normal scheduler"""     ,		)

         snake_case__						= scheduler_func(self.optimizer     ,		**_a   )
         if scheduler_func.__name__ != "get_constant_schedule":
           LambdaScheduleWrapper.wrap_scheduler(_a   )  # wrap to test picklability of the schedule
         snake_case__						= unwrap_and_save_reload_schedule(_a     ,		self.num_steps   )
         self.assertListEqual(_a     ,		_a     ,		msg=F"""failed for {scheduler_func} in save and reload"""   )




class 		__magic_name__						:





     '''simple docstring'''



     def __init__(					self:Any     ,		_a:Dict   ):
       snake_case__						= fn

     def __call__(					self:Any     ,		*_a:Dict     ,		**_a:List[str]   ):
       return self.fn(*_a     ,		**_a   )







     @classmethod
     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[Any]     ,		_a:Tuple   ):
       snake_case__						= list(map(self     ,		scheduler.lr_lambdas   )   )





def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase = 100				)    ->				int:
  snake_case__						= set()

  snake_case__						= 0

  snake_case__						= n + 1  # maximum limit

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


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

