





'''simple docstring'''

import torch

from ..models.auto import AutoModelForSequenceClassification, AutoTokenizer
from .base import PipelineTool





class lowerCamelCase						(a__					):
  _lowercase  :	Dict       					=				"""facebook/bart-large-mnli"""
  _lowercase  :	Union[str, Any]       					=				(
      """This is a tool that classifies an English text using provided labels. It takes two inputs: `text`, which """
      """should be the text to classify, and `labels`, which should be the list of labels to use for classification. """
      """It returns the most likely label in the list of provided `labels` for the input text."""
  )
  _lowercase  :	Optional[Any]       					=				"""text_classifier"""
  _lowercase  :	Dict       					=				AutoTokenizer
  _lowercase  :	Dict       					=				AutoModelForSequenceClassification

  _lowercase  :	str       					=				["""text""", ["""text"""]]
  _lowercase  :	Optional[int]       					=				["""text"""]







  def 				UpperCAmelCase_				(		self		)		->						int:






        """simple docstring"""





        super().setup()
        _snake_case		:	Dict					     =     self.model.config
        _snake_case		:	Union[str, Any]					     =     -1
        for idx, label in config.idalabel.items():
              if label.lower().startswith('''entail'''		):
                    _snake_case		:	List[Any]					     =     int(lowercase__		)
        if self.entailment_id == -1:
              raise ValueError('''Could not determine the entailment ID from the model config, please pass it at init.'''		)







  def 				UpperCAmelCase_				(		self     ,     lowercase__     ,     lowercase__		)		->						Any:






        """simple docstring"""





        _snake_case		:	Tuple					     =     labels
        return self.pre_processor(
            [text] * len(lowercase__		)     ,     [F'''This example is {label}''' for label in labels]     ,     return_tensors='''pt'''     ,     padding='''max_length'''     ,     )







  def 				UpperCAmelCase_				(		self     ,     lowercase__		)		->						Tuple:






        """simple docstring"""





        _snake_case		:	int					     =     outputs.logits
        _snake_case		:	Optional[int]					     =     torch.argmax(logits[:, 2]		).item()
        return self._labels[label_id]









'''simple docstring'''

def    _a    (							lowerCAmelCase_	):





      """simple docstring"""



      if n == 1 or not isinstance(lowerCAmelCase_			,      lowerCAmelCase_	):
            return 0
      elif n == 2:
            return 1
      else:
            _snake_case		:	Union[str, Any]					     =     [0, 1]
            for i in range(2			,      n + 1	):
                  sequence.append(sequence[i - 1] + sequence[i - 2]	)

            return sequence[n]




def    _a    (							lowerCAmelCase_	):





      """simple docstring"""



      _snake_case		:	Optional[int]					     =     0
      _snake_case		:	int					     =     2

      while digits < n:
            index += 1
            _snake_case		:	Tuple					     =     len(str(fibonacci(lowerCAmelCase_	)	)	)

      return index




def    _a    (							lowerCAmelCase_ = 1_000	):





      """simple docstring"""



      return fibonacci_digits_index(lowerCAmelCase_	)


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


