





"""simple docstring"""
import logging
from pathlib import Path

import numpy as np
import pytorch_lightning as pl
import torch
from pytorch_lightning.callbacks import EarlyStopping, ModelCheckpoint
from pytorch_lightning.utilities import rank_zero_only
from utils_rag import save_json



def      __lowerCamelCase   (							a_     :		Optional[int]							)			->      Union[str, Any]:
      __SCREAMING_SNAKE_CASE   :int						=  filter(lambda a_							: p.requires_grad ,   model.parameters()							)
      __SCREAMING_SNAKE_CASE   :List[Any]						=  sum([np.prod(p.size()							) for p in model_parameters]							)
      return params


lowerCamelCase_								=		logging.getLogger(__name__)



def      __lowerCamelCase   (							a_     :		str ,   a_     :		List[Any]							)			->      str:





      if metric == "rouge2":
            __SCREAMING_SNAKE_CASE   :List[Any]						=  """{val_avg_rouge2:.4f}-{step_count}"""
      elif metric == "bleu":
            __SCREAMING_SNAKE_CASE   :Dict						=  """{val_avg_bleu:.4f}-{step_count}"""
      elif metric == "em":
            __SCREAMING_SNAKE_CASE   :Dict						=  """{val_avg_em:.4f}-{step_count}"""
      elif metric == "loss":
            __SCREAMING_SNAKE_CASE   :str						=  """{val_avg_loss:.4f}-{step_count}"""
      else:
            raise NotImplementedError(
                f'''seq2seq callbacks only support rouge2 and bleu, got {metric}, You can make your own by adding to this'''
                ''' function.'''							)

      __SCREAMING_SNAKE_CASE   :Optional[int]						=  ModelCheckpoint(
          dirpath=A__ ,   filename=A__ ,   monitor=f'''val_{metric}''' ,   mode='''max''' ,   save_top_k=1 ,   every_n_epochs=1 ,   )

      return checkpoint_callback



def      __lowerCamelCase   (							a_     :		List[Any] ,   a_     :		Any							)			->      List[Any]:
      return EarlyStopping(
          monitor=f'''val_{metric}''' ,   mode='''min''' if '''loss''' in metric else '''max''' ,   patience=A__ ,   verbose=A__ ,   )







class 					_SCREAMING_SNAKE_CASE(   pl.Callback  ):




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)			->      Dict:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :List[Any]						=  {f'''lr_group_{i}''': param["""lr"""] for i, param in enumerate(pl_module.trainer.optimizers[0].param_groups							)}
             pl_module.logger.log_metrics(SCREAMING_SNAKE_CASE__							)




       @rank_zero_only
       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__=True							)			->      None:





             """simple docstring"""






             logger.info(f'''***** {type_path} results at step {trainer.global_step:05d} *****'''							)
             __SCREAMING_SNAKE_CASE   :Tuple						=  trainer.callback_metrics
             trainer.logger.log_metrics({k: v for k, v in metrics.items() if k not in ['''log''', '''progress_bar''', '''preds''']}							)
             # Log results
             __SCREAMING_SNAKE_CASE   :Optional[Any]						=  Path(pl_module.hparams.output_dir							)
             if type_path == "test":
                   __SCREAMING_SNAKE_CASE   :Dict						=  od / """test_results.txt"""
                   __SCREAMING_SNAKE_CASE   :Optional[Any]						=  od / """test_generations.txt"""
             else:
                   # this never gets hit. I prefer not to save intermediate generations, and results are in metrics.json
                   # If people want this it will be easy enough to add back.
                   __SCREAMING_SNAKE_CASE   :List[str]						=  od / f'''{type_path}_results/{trainer.global_step:05d}.txt'''
                   __SCREAMING_SNAKE_CASE   :str						=  od / f'''{type_path}_generations/{trainer.global_step:05d}.txt'''
                   results_file.parent.mkdir(exist_ok=SCREAMING_SNAKE_CASE__							)
                   generations_file.parent.mkdir(exist_ok=SCREAMING_SNAKE_CASE__							)
             with open(SCREAMING_SNAKE_CASE__		,'''a+'''							) as writer:
                   for key in sorted(SCREAMING_SNAKE_CASE__							):
                         if key in ["log", "progress_bar", "preds"]:
                               continue
                         __SCREAMING_SNAKE_CASE   :Dict						=  metrics[key]
                         if isinstance(SCREAMING_SNAKE_CASE__		,torch.Tensor							):
                               __SCREAMING_SNAKE_CASE   :Dict						=  val.item()
                         __SCREAMING_SNAKE_CASE   :Any						=  f'''{key}: {val:.6f}\n'''
                         writer.write(SCREAMING_SNAKE_CASE__							)

             if not save_generations:
                   return

             if "preds" in metrics:
                   __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  """\n""".join(metrics['''preds''']							)
                   generations_file.open('''w+'''							).write(SCREAMING_SNAKE_CASE__							)




       @rank_zero_only
       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)			->      Union[str, Any]:





             """simple docstring"""






             try:
                   __SCREAMING_SNAKE_CASE   :Optional[int]						=  pl_module.model.model.num_parameters()
             except AttributeError:
                   __SCREAMING_SNAKE_CASE   :Dict						=  pl_module.model.num_parameters()

             __SCREAMING_SNAKE_CASE   :Any						=  count_trainable_parameters(SCREAMING_SNAKE_CASE__							)
             # mp stands for million parameters
             trainer.logger.log_metrics({'''n_params''': npars, '''mp''': npars / 1E6, '''grad_mp''': n_trainable_pars / 1E6}							)




       @rank_zero_only
       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)			->      Union[str, Any]:





             """simple docstring"""






             save_json(pl_module.metrics		,pl_module.metrics_save_path							)
             return self._write_logs(SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,'''test'''							)




       @rank_zero_only
       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)			->      int:





             """simple docstring"""






             save_json(pl_module.metrics		,pl_module.metrics_save_path							)
             # Uncommenting this will save val generations
             # return self._write_logs(trainer, pl_module, "valid")



'''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())))



