


import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_base import BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import PaddingStrategy, logging
from .tokenization_realm import RealmTokenizer


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

lowerCamelCase__							:						Optional[int]							     =   {"""vocab_file""": """vocab.txt""", """tokenizer_file""": """tokenizer.json"""}

lowerCamelCase__							:						Dict							     =   {
    """vocab_file""": {
        """google/realm-cc-news-pretrained-embedder""": (
            """https://huggingface.co/google/realm-cc-news-pretrained-embedder/resolve/main/vocab.txt"""
        ),
        """google/realm-cc-news-pretrained-encoder""": (
            """https://huggingface.co/google/realm-cc-news-pretrained-encoder/resolve/main/vocab.txt"""
        ),
        """google/realm-cc-news-pretrained-scorer""": (
            """https://huggingface.co/google/realm-cc-news-pretrained-scorer/resolve/main/vocab.txt"""
        ),
        """google/realm-cc-news-pretrained-openqa""": (
            """https://huggingface.co/google/realm-cc-news-pretrained-openqa/aresolve/main/vocab.txt"""
        ),
        """google/realm-orqa-nq-openqa""": """https://huggingface.co/google/realm-orqa-nq-openqa/resolve/main/vocab.txt""",
        """google/realm-orqa-nq-reader""": """https://huggingface.co/google/realm-orqa-nq-reader/resolve/main/vocab.txt""",
        """google/realm-orqa-wq-openqa""": """https://huggingface.co/google/realm-orqa-wq-openqa/resolve/main/vocab.txt""",
        """google/realm-orqa-wq-reader""": """https://huggingface.co/google/realm-orqa-wq-reader/resolve/main/vocab.txt""",
    },
    """tokenizer_file""": {
        """google/realm-cc-news-pretrained-embedder""": (
            """https://huggingface.co/google/realm-cc-news-pretrained-embedder/resolve/main/tokenizer.jsont"""
        ),
        """google/realm-cc-news-pretrained-encoder""": (
            """https://huggingface.co/google/realm-cc-news-pretrained-encoder/resolve/main/tokenizer.json"""
        ),
        """google/realm-cc-news-pretrained-scorer""": (
            """https://huggingface.co/google/realm-cc-news-pretrained-scorer/resolve/main/tokenizer.json"""
        ),
        """google/realm-cc-news-pretrained-openqa""": (
            """https://huggingface.co/google/realm-cc-news-pretrained-openqa/aresolve/main/tokenizer.json"""
        ),
        """google/realm-orqa-nq-openqa""": (
            """https://huggingface.co/google/realm-orqa-nq-openqa/resolve/main/tokenizer.json"""
        ),
        """google/realm-orqa-nq-reader""": (
            """https://huggingface.co/google/realm-orqa-nq-reader/resolve/main/tokenizer.json"""
        ),
        """google/realm-orqa-wq-openqa""": (
            """https://huggingface.co/google/realm-orqa-wq-openqa/resolve/main/tokenizer.json"""
        ),
        """google/realm-orqa-wq-reader""": (
            """https://huggingface.co/google/realm-orqa-wq-reader/resolve/main/tokenizer.json"""
        ),
    },
}

lowerCamelCase__							:						Optional[int]							     =   {
    """google/realm-cc-news-pretrained-embedder""": 5_1_2,
    """google/realm-cc-news-pretrained-encoder""": 5_1_2,
    """google/realm-cc-news-pretrained-scorer""": 5_1_2,
    """google/realm-cc-news-pretrained-openqa""": 5_1_2,
    """google/realm-orqa-nq-openqa""": 5_1_2,
    """google/realm-orqa-nq-reader""": 5_1_2,
    """google/realm-orqa-wq-openqa""": 5_1_2,
    """google/realm-orqa-wq-reader""": 5_1_2,
}

lowerCamelCase__							:						Optional[Any]							     =   {
    """google/realm-cc-news-pretrained-embedder""": {"""do_lower_case""": True},
    """google/realm-cc-news-pretrained-encoder""": {"""do_lower_case""": True},
    """google/realm-cc-news-pretrained-scorer""": {"""do_lower_case""": True},
    """google/realm-cc-news-pretrained-openqa""": {"""do_lower_case""": True},
    """google/realm-orqa-nq-openqa""": {"""do_lower_case""": True},
    """google/realm-orqa-nq-reader""": {"""do_lower_case""": True},
    """google/realm-orqa-wq-openqa""": {"""do_lower_case""": True},
    """google/realm-orqa-wq-reader""": {"""do_lower_case""": True},
}
class 		__magic_name__						(snake_case_				):





     '''simple docstring'''



     __lowercase				:							Optional[Any]	   =       VOCAB_FILES_NAMES
     __lowercase				:							Dict	   =       PRETRAINED_VOCAB_FILES_MAP
     __lowercase				:							List[Any]	   =       PRETRAINED_INIT_CONFIGURATION
     __lowercase				:							int	   =       PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     __lowercase				:							Union[str, Any]	   =       RealmTokenizer

     def __init__(					self:Dict     ,		_a:List[str]=None     ,		_a:Union[str, Any]=None     ,		_a:Dict=True     ,		_a:List[Any]="[UNK]"     ,		_a:Any="[SEP]"     ,		_a:Union[str, Any]="[PAD]"     ,		_a:int="[CLS]"     ,		_a:Tuple="[MASK]"     ,		_a:List[Any]=True     ,		_a:str=None     ,		**_a:Any     ,		):
       super().__init__(
           _a     ,		tokenizer_file=_a     ,		do_lower_case=_a     ,		unk_token=_a     ,		sep_token=_a     ,		pad_token=_a     ,		cls_token=_a     ,		mask_token=_a     ,		tokenize_chinese_chars=_a     ,		strip_accents=_a     ,		**_a     ,		)

       snake_case__						= json.loads(self.backend_tokenizer.normalizer.__getstate__()   )
       if (
           normalizer_state.get('''lowercase'''     ,		_a   ) != do_lower_case
           or normalizer_state.get('''strip_accents'''     ,		_a   ) != strip_accents
           or normalizer_state.get('''handle_chinese_chars'''     ,		_a   ) != tokenize_chinese_chars
       ):
         snake_case__						= getattr(_a     ,		normalizer_state.pop('''type'''   )   )
         snake_case__						= do_lower_case
         snake_case__						= strip_accents
         snake_case__						= tokenize_chinese_chars
         snake_case__						= normalizer_class(**_a   )

       snake_case__						= do_lower_case

     def 	SCREAMING_SNAKE_CASE__						(					self:Tuple     ,		_a:int     ,		**_a:int   ):
       snake_case__						= PaddingStrategy.MAX_LENGTH

       snake_case__						= text
       snake_case__						= kwargs.pop('''text_pair'''     ,		_a   )
       snake_case__						= kwargs.pop('''return_tensors'''     ,		_a   )

       snake_case__						= {
           '''input_ids''': [],
           '''attention_mask''': [],
           '''token_type_ids''': [],
       }

       for idx, candidate_text in enumerate(_a   ):
         if batch_text_pair is not None:
           snake_case__						= batch_text_pair[idx]
         else:
           snake_case__						= None

         snake_case__						= super().__call__(_a     ,		_a     ,		return_tensors=_a     ,		**_a   )

         snake_case__						= encoded_candidates.get('''input_ids'''   )
         snake_case__						= encoded_candidates.get('''attention_mask'''   )
         snake_case__						= encoded_candidates.get('''token_type_ids'''   )

         if encoded_input_ids is not None:
           output_data["input_ids"].append(_a   )
         if encoded_attention_mask is not None:
           output_data["attention_mask"].append(_a   )
         if encoded_token_type_ids is not None:
           output_data["token_type_ids"].append(_a   )

       snake_case__						= {key: item for key, item in output_data.items() if len(_a   ) != 0}

       return BatchEncoding(_a     ,		tensor_type=_a   )

     def 	SCREAMING_SNAKE_CASE__						(					self:Tuple     ,		_a:int     ,		_a:int=None   ):
       snake_case__						= [self.cls_token_id] + token_ids_a + [self.sep_token_id]

       if token_ids_a:
         output += token_ids_a + [self.sep_token_id]

       return output

     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[Any]     ,		_a:List[int]     ,		_a:Optional[List[int]] = None   ):
       snake_case__						= [self.sep_token_id]
       snake_case__						= [self.cls_token_id]
       if token_ids_a is None:
         return len(cls + token_ids_a + sep   ) * [0]
       return len(cls + token_ids_a + sep   ) * [0] + len(token_ids_a + sep   ) * [1]







     def 	SCREAMING_SNAKE_CASE__						(					self:Any     ,		_a:str     ,		_a:Optional[str] = None   ):
       snake_case__						= self._tokenizer.model.save(_a     ,		name=_a   )
       return tuple(_a   )





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

