






import json
from typing import TYPE_CHECKING, List, Optional, Tuple

from tokenizers import pre_tokenizers, processors

from ...tokenization_utils_base import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_blenderbot import BlenderbotTokenizer


if TYPE_CHECKING:
 from transformers.pipelines.conversational import Conversation

snake_case__      :	Dict       	=      logging.get_logger(__name__)


snake_case__      :	str       	=      {
    """vocab_file""": """vocab.json""",
    """merges_file""": """merges.txt""",
    """tokenizer_config_file""": """tokenizer_config.json""",
}

snake_case__      :	Optional[int]       	=      {
    """vocab_file""": {"""facebook/blenderbot-3B""": """https://huggingface.co/facebook/blenderbot-3B/resolve/main/vocab.json"""},
    """merges_file""": {"""facebook/blenderbot-3B""": """https://huggingface.co/facebook/blenderbot-3B/resolve/main/merges.txt"""},
    """tokenizer_config_file""": {
        """facebook/blenderbot-3B""": """https://huggingface.co/facebook/blenderbot-3B/resolve/main/tokenizer_config.json"""
    },
}

snake_case__      :	Tuple       	=      {"""facebook/blenderbot-3B""": 1_2_8}


class 						_a       (  UpperCAmelCase__    ):






  """simple docstring"""





  A_						=   VOCAB_FILES_NAMES
  A_						=   PRETRAINED_VOCAB_FILES_MAP
  A_						=   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  A_						=   ["""input_ids""", """attention_mask"""]
  A_						=   BlenderbotTokenizer




  def __init__(     self		,		_UpperCAmelCase=None		,		_UpperCAmelCase=None		,		_UpperCAmelCase=None		,		_UpperCAmelCase="replace"		,		_UpperCAmelCase="<s>"		,		_UpperCAmelCase="</s>"		,		_UpperCAmelCase="</s>"		,		_UpperCAmelCase="<s>"		,		_UpperCAmelCase="<unk>"		,		_UpperCAmelCase="<pad>"		,		_UpperCAmelCase="<mask>"		,		_UpperCAmelCase=False		,		_UpperCAmelCase=True		,		**_UpperCAmelCase		,		)			-> Any:
     super().__init__(
         _UpperCAmelCase		,		_UpperCAmelCase		,		tokenizer_file=_UpperCAmelCase		,		errors=_UpperCAmelCase		,		bos_token=_UpperCAmelCase		,		eos_token=_UpperCAmelCase		,		sep_token=_UpperCAmelCase		,		cls_token=_UpperCAmelCase		,		unk_token=_UpperCAmelCase		,		pad_token=_UpperCAmelCase		,		mask_token=_UpperCAmelCase		,		add_prefix_space=_UpperCAmelCase		,		trim_offsets=_UpperCAmelCase		,		**_UpperCAmelCase		,		)

     UpperCamelCase_									=     json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__() )
     if pre_tok_state.get('add_prefix_space'		,		_UpperCAmelCase ) != add_prefix_space:
        UpperCamelCase_									=     getattr(_UpperCAmelCase		,		pre_tok_state.pop('type' ) )
        UpperCamelCase_									=     add_prefix_space
        UpperCamelCase_									=     pre_tok_class(**_UpperCAmelCase )

     UpperCamelCase_									=     add_prefix_space

     UpperCamelCase_									=     'post_processor'
     UpperCamelCase_									=     getattr(self.backend_tokenizer		,		_UpperCAmelCase		,		_UpperCAmelCase )
     if tokenizer_component_instance:
        UpperCamelCase_									=     json.loads(tokenizer_component_instance.__getstate__() )

        # The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class`
        if "sep" in state:
           UpperCamelCase_									=     tuple(state['sep'] )
        if "cls" in state:
           UpperCamelCase_									=     tuple(state['cls'] )

        UpperCamelCase_									=     False

        if state.get('add_prefix_space'		,		_UpperCAmelCase ) != add_prefix_space:
           UpperCamelCase_									=     add_prefix_space
           UpperCamelCase_									=     True

        if state.get('trim_offsets'		,		_UpperCAmelCase ) != trim_offsets:
           UpperCamelCase_									=     trim_offsets
           UpperCamelCase_									=     True

        if changes_to_apply:
           UpperCamelCase_									=     getattr(_UpperCAmelCase		,		state.pop('type' ) )
           UpperCamelCase_									=     component_class(**_UpperCAmelCase )
           setattr(self.backend_tokenizer		,		_UpperCAmelCase		,		_UpperCAmelCase )




  @property
  # Copied from transformers.models.roberta.tokenization_roberta_fast.RobertaTokenizerFast.mask_token with Roberta->Blenderbot, RoBERTa->Blenderbot
  def    _UpperCAmelCase     (     self )			-> str:
     if self._mask_token is None:
        if self.verbose:
           logger.error('Using mask_token, but it is not set yet.' )
        return None
     return str(self._mask_token )




  @mask_token.setter
  def    _UpperCAmelCase     (     self		,		_UpperCAmelCase )			-> Optional[Any]:
     UpperCamelCase_									=     AddedToken(_UpperCAmelCase		,		lstrip=_UpperCAmelCase		,		rstrip=_UpperCAmelCase ) if isinstance(_UpperCAmelCase		,		_UpperCAmelCase ) else value
     UpperCamelCase_									=     value




  def    _UpperCAmelCase     (     self		,		*_UpperCAmelCase		,		**_UpperCAmelCase )			-> BatchEncoding:
     UpperCamelCase_									=     kwargs.get('is_split_into_words'		,		_UpperCAmelCase )
     assert self.add_prefix_space or not is_split_into_words, (
         f"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """
         "to use it with pretokenized inputs."
     )

     return super()._batch_encode_plus(*_UpperCAmelCase		,		**_UpperCAmelCase )




  def    _UpperCAmelCase     (     self		,		*_UpperCAmelCase		,		**_UpperCAmelCase )			-> BatchEncoding:
     UpperCamelCase_									=     kwargs.get('is_split_into_words'		,		_UpperCAmelCase )

     assert self.add_prefix_space or not is_split_into_words, (
         f"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """
         "to use it with pretokenized inputs."
     )

     return super()._encode_plus(*_UpperCAmelCase		,		**_UpperCAmelCase )




  def    _UpperCAmelCase     (     self		,		_UpperCAmelCase		,		_UpperCAmelCase = None )			-> Tuple[str]:
     UpperCamelCase_									=     self._tokenizer.model.save(_UpperCAmelCase		,		name=_UpperCAmelCase )
     return tuple(_UpperCAmelCase )




  def    _UpperCAmelCase     (     self		,		_UpperCAmelCase		,		_UpperCAmelCase = None )			-> List[int]:
     UpperCamelCase_									=     [self.sep_token_id]
     UpperCamelCase_									=     [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 + sep + token_ids_a + sep ) * [0]




  def    _UpperCAmelCase     (     self		,		_UpperCAmelCase		,		_UpperCAmelCase = None )			-> int:
     return token_ids_a + [self.eos_token_id]




  def    _UpperCAmelCase     (     self		,		_UpperCAmelCase )			-> List[int]:
     UpperCamelCase_									=     []
     for is_user, text in conversation.iter_texts():
        if is_user:
           # We need to space prefix as it's being done within blenderbot
           inputs.append(' ' + text )
        else:
           # Generated responses should contain them already.
           inputs.append(_UpperCAmelCase )

     UpperCamelCase_									=     '  '.join(_UpperCAmelCase )
     UpperCamelCase_									=     self.encode(_UpperCAmelCase )
     if len(_UpperCAmelCase ) > self.model_max_length:
        UpperCamelCase_									=     input_ids[-self.model_max_length :]
        logger.warning(f"""Trimmed input from conversation as it was longer than {self.model_max_length} tokens.""" )
     return input_ids













def     _snake_case    (__lowercase = 1000):
   UpperCamelCase_		,      UpperCamelCase_									=     1, 1
   UpperCamelCase_									=     2
   while True:
      UpperCamelCase_									=     0
      UpperCamelCase_									=     fa + fa
      UpperCamelCase_		,      UpperCamelCase_									=     fa, f
      index += 1
      for _ in str(__lowercase):
         i += 1
      if i == n:
         break
   return index


if __name__ == "__main__":
 print(solution(int(str(input()).strip())))





