




'''simple docstring'''



import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    Pipeline,
    ZeroShotClassificationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow

from .test_pipelines_common import ANY


# These 2 model types require different inputs than those of the usual text models.
lowerCamelCase_			=						{'LayoutLMv2Config', 'LayoutLMv3Config'}







@is_pipeline_test
class 		lowercase_   (			unittest.TestCase       ):


			"""simple docstring"""

			lowerCamelCase_      =						MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
			lowerCamelCase_      =						TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

			if model_mapping is not None:
						lowerCamelCase_      =						{config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
			if tf_model_mapping is not None:
						lowerCamelCase_      =						{
						    config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
						}



			def 							lowerCAmelCase_      (   self :     Dict  ,				__lowerCamelCase :     Union[str, Any]  ,				__lowerCamelCase :     Optional[Any]  ,				__lowerCamelCase :     List[Any]   ):

						"""simple docstring"""
						_SCREAMING_SNAKE_CASE	=				ZeroShotClassificationPipeline(
						    model=__lowerCamelCase  ,				tokenizer=__lowerCamelCase  ,				candidate_labels=["polics", "health"]   )
						return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]



			def 							lowerCAmelCase_      (   self :     List[Any]  ,				__lowerCamelCase :     List[str]  ,				__lowerCamelCase :     Any   ):

						"""simple docstring"""
						_SCREAMING_SNAKE_CASE	=				classifier("Who are you voting for in 2020?"  ,				candidate_labels="politics"   )
						self.assertEqual(__lowerCamelCase  ,				{"sequence": ANY(__lowerCamelCase   ), "labels": [ANY(__lowerCamelCase   )], "scores": [ANY(__lowerCamelCase   )]}   )

						# No kwarg
						_SCREAMING_SNAKE_CASE	=				classifier("Who are you voting for in 2020?"  ,				["politics"]   )
						self.assertEqual(__lowerCamelCase  ,				{"sequence": ANY(__lowerCamelCase   ), "labels": [ANY(__lowerCamelCase   )], "scores": [ANY(__lowerCamelCase   )]}   )

						_SCREAMING_SNAKE_CASE	=				classifier("Who are you voting for in 2020?"  ,				candidate_labels=["politics"]   )
						self.assertEqual(__lowerCamelCase  ,				{"sequence": ANY(__lowerCamelCase   ), "labels": [ANY(__lowerCamelCase   )], "scores": [ANY(__lowerCamelCase   )]}   )

						_SCREAMING_SNAKE_CASE	=				classifier("Who are you voting for in 2020?"  ,				candidate_labels="politics, public health"   )
						self.assertEqual(
						    __lowerCamelCase  ,				{"sequence": ANY(__lowerCamelCase   ), "labels": [ANY(__lowerCamelCase   ), ANY(__lowerCamelCase   )], "scores": [ANY(__lowerCamelCase   ), ANY(__lowerCamelCase   )]}   )
						self.assertAlmostEqual(sum(nested_simplify(outputs["scores"]   )   )  ,				1.0   )

						_SCREAMING_SNAKE_CASE	=				classifier("Who are you voting for in 2020?"  ,				candidate_labels=["politics", "public health"]   )
						self.assertEqual(
						    __lowerCamelCase  ,				{"sequence": ANY(__lowerCamelCase   ), "labels": [ANY(__lowerCamelCase   ), ANY(__lowerCamelCase   )], "scores": [ANY(__lowerCamelCase   ), ANY(__lowerCamelCase   )]}   )
						self.assertAlmostEqual(sum(nested_simplify(outputs["scores"]   )   )  ,				1.0   )

						_SCREAMING_SNAKE_CASE	=				classifier(
						    "Who are you voting for in 2020?"  ,				candidate_labels="politics"  ,				hypothesis_template="This text is about {}"   )
						self.assertEqual(__lowerCamelCase  ,				{"sequence": ANY(__lowerCamelCase   ), "labels": [ANY(__lowerCamelCase   )], "scores": [ANY(__lowerCamelCase   )]}   )

						# https://github.com/huggingface/transformers/issues/13846
						_SCREAMING_SNAKE_CASE	=				classifier(["I am happy"]  ,				["positive", "negative"]   )
						self.assertEqual(
						    __lowerCamelCase  ,				[
						        {"sequence": ANY(__lowerCamelCase   ), "labels": [ANY(__lowerCamelCase   ), ANY(__lowerCamelCase   )], "scores": [ANY(__lowerCamelCase   ), ANY(__lowerCamelCase   )]}
						        for i in range(1   )
						    ]  ,				)
						_SCREAMING_SNAKE_CASE	=				classifier(["I am happy", "I am sad"]  ,				["positive", "negative"]   )
						self.assertEqual(
						    __lowerCamelCase  ,				[
						        {"sequence": ANY(__lowerCamelCase   ), "labels": [ANY(__lowerCamelCase   ), ANY(__lowerCamelCase   )], "scores": [ANY(__lowerCamelCase   ), ANY(__lowerCamelCase   )]}
						        for i in range(2   )
						    ]  ,				)

						with self.assertRaises(__lowerCamelCase   ):
									classifier(""  ,				candidate_labels="politics"   )

						with self.assertRaises(__lowerCamelCase   ):
									classifier(__lowerCamelCase  ,				candidate_labels="politics"   )

						with self.assertRaises(__lowerCamelCase   ):
									classifier("Who are you voting for in 2020?"  ,				candidate_labels=""   )

						with self.assertRaises(__lowerCamelCase   ):
									classifier("Who are you voting for in 2020?"  ,				candidate_labels=__lowerCamelCase   )

						with self.assertRaises(__lowerCamelCase   ):
									classifier(
									    "Who are you voting for in 2020?"  ,				candidate_labels="politics"  ,				hypothesis_template="Not formatting template"  ,				)

						with self.assertRaises(__lowerCamelCase   ):
									classifier(
									    "Who are you voting for in 2020?"  ,				candidate_labels="politics"  ,				hypothesis_template=__lowerCamelCase  ,				)

						self.run_entailment_id(__lowerCamelCase   )



			def 							lowerCAmelCase_      (   self :     Optional[Any]  ,				__lowerCamelCase :     Pipeline   ):

						"""simple docstring"""
						_SCREAMING_SNAKE_CASE	=				zero_shot_classifier.model.config
						_SCREAMING_SNAKE_CASE	=				config.labelaid
						_SCREAMING_SNAKE_CASE	=				zero_shot_classifier.entailment_id

						_SCREAMING_SNAKE_CASE	=				{"LABEL_0": 0, "LABEL_1": 1, "LABEL_2": 2}
						self.assertEqual(zero_shot_classifier.entailment_id  ,				-1   )

						_SCREAMING_SNAKE_CASE	=				{"entailment": 0, "neutral": 1, "contradiction": 2}
						self.assertEqual(zero_shot_classifier.entailment_id  ,				0   )

						_SCREAMING_SNAKE_CASE	=				{"ENTAIL": 0, "NON-ENTAIL": 1}
						self.assertEqual(zero_shot_classifier.entailment_id  ,				0   )

						_SCREAMING_SNAKE_CASE	=				{"ENTAIL": 2, "NEUTRAL": 1, "CONTR": 0}
						self.assertEqual(zero_shot_classifier.entailment_id  ,				2   )

						_SCREAMING_SNAKE_CASE	=				original_labelaid
						self.assertEqual(__lowerCamelCase  ,				zero_shot_classifier.entailment_id   )



			@require_torch
			def 							lowerCAmelCase_      (   self :     int   ):

						"""simple docstring"""
						_SCREAMING_SNAKE_CASE	=				pipeline(
						    "zero-shot-classification"  ,				model="sshleifer/tiny-distilbert-base-cased-distilled-squad"  ,				framework="pt"  ,				)
						# There was a regression in 4.10 for this
						# Adding a test so we don't make the mistake again.
						# https://github.com/huggingface/transformers/issues/13381#issuecomment-912343499
						zero_shot_classifier(
						    "Who are you voting for in 2020?" * 1_0_0  ,				candidate_labels=["politics", "public health", "science"]   )



			@require_torch
			def 							lowerCAmelCase_      (   self :     Optional[Any]   ):

						"""simple docstring"""
						_SCREAMING_SNAKE_CASE	=				pipeline(
						    "zero-shot-classification"  ,				model="sshleifer/tiny-distilbert-base-cased-distilled-squad"  ,				framework="pt"  ,				)
						_SCREAMING_SNAKE_CASE	=				zero_shot_classifier(
						    "Who are you voting for in 2020?"  ,				candidate_labels=["politics", "public health", "science"]   )

						self.assertEqual(
						    nested_simplify(__lowerCamelCase   )  ,				{
						        "sequence": "Who are you voting for in 2020?",
						        "labels": ["science", "public health", "politics"],
						        "scores": [0.3_3_3, 0.3_3_3, 0.3_3_3],
						    }  ,				)



			@require_tf
			def 							lowerCAmelCase_      (   self :     List[Any]   ):

						"""simple docstring"""
						_SCREAMING_SNAKE_CASE	=				pipeline(
						    "zero-shot-classification"  ,				model="sshleifer/tiny-distilbert-base-cased-distilled-squad"  ,				framework="tf"  ,				)
						_SCREAMING_SNAKE_CASE	=				zero_shot_classifier(
						    "Who are you voting for in 2020?"  ,				candidate_labels=["politics", "public health", "science"]   )

						self.assertEqual(
						    nested_simplify(__lowerCamelCase   )  ,				{
						        "sequence": "Who are you voting for in 2020?",
						        "labels": ["science", "public health", "politics"],
						        "scores": [0.3_3_3, 0.3_3_3, 0.3_3_3],
						    }  ,				)



			@slow
			@require_torch
			def 							lowerCAmelCase_      (   self :     Any   ):

						"""simple docstring"""
						_SCREAMING_SNAKE_CASE	=				pipeline("zero-shot-classification"  ,				model="roberta-large-mnli"  ,				framework="pt"   )
						_SCREAMING_SNAKE_CASE	=				zero_shot_classifier(
						    "Who are you voting for in 2020?"  ,				candidate_labels=["politics", "public health", "science"]   )

						self.assertEqual(
						    nested_simplify(__lowerCamelCase   )  ,				{
						        "sequence": "Who are you voting for in 2020?",
						        "labels": ["politics", "public health", "science"],
						        "scores": [0.9_7_6, 0.0_1_5, 0.0_0_9],
						    }  ,				)
						_SCREAMING_SNAKE_CASE	=				zero_shot_classifier(
						    "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks"
						    " in an encoder-decoder configuration. The best performing models also connect the encoder and decoder"
						    " through an attention mechanism. We propose a new simple network architecture, the Transformer, based"
						    " solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two"
						    " machine translation tasks show these models to be superior in quality while being more parallelizable"
						    " and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014"
						    " English-to-German translation task, improving over the existing best results, including ensembles by"
						    " over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new"
						    " single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small"
						    " fraction of the training costs of the best models from the literature. We show that the Transformer"
						    " generalizes well to other tasks by applying it successfully to English constituency parsing both with"
						    " large and limited training data."  ,				candidate_labels=["machine learning", "statistics", "translation", "vision"]  ,				multi_label=__lowerCamelCase  ,				)
						self.assertEqual(
						    nested_simplify(__lowerCamelCase   )  ,				{
						        "sequence": (
						            "The dominant sequence transduction models are based on complex recurrent or convolutional neural"
						            " networks in an encoder-decoder configuration. The best performing models also connect the"
						            " encoder and decoder through an attention mechanism. We propose a new simple network"
						            " architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence"
						            " and convolutions entirely. Experiments on two machine translation tasks show these models to be"
						            " superior in quality while being more parallelizable and requiring significantly less time to"
						            " train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,"
						            " improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014"
						            " English-to-French translation task, our model establishes a new single-model state-of-the-art"
						            " BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training"
						            " costs of the best models from the literature. We show that the Transformer generalizes well to"
						            " other tasks by applying it successfully to English constituency parsing both with large and"
						            " limited training data."
						        ),
						        "labels": ["translation", "machine learning", "vision", "statistics"],
						        "scores": [0.8_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
						    }  ,				)



			@slow
			@require_tf
			def 							lowerCAmelCase_      (   self :     Union[str, Any]   ):

						"""simple docstring"""
						_SCREAMING_SNAKE_CASE	=				pipeline("zero-shot-classification"  ,				model="roberta-large-mnli"  ,				framework="tf"   )
						_SCREAMING_SNAKE_CASE	=				zero_shot_classifier(
						    "Who are you voting for in 2020?"  ,				candidate_labels=["politics", "public health", "science"]   )

						self.assertEqual(
						    nested_simplify(__lowerCamelCase   )  ,				{
						        "sequence": "Who are you voting for in 2020?",
						        "labels": ["politics", "public health", "science"],
						        "scores": [0.9_7_6, 0.0_1_5, 0.0_0_9],
						    }  ,				)
						_SCREAMING_SNAKE_CASE	=				zero_shot_classifier(
						    "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks"
						    " in an encoder-decoder configuration. The best performing models also connect the encoder and decoder"
						    " through an attention mechanism. We propose a new simple network architecture, the Transformer, based"
						    " solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two"
						    " machine translation tasks show these models to be superior in quality while being more parallelizable"
						    " and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014"
						    " English-to-German translation task, improving over the existing best results, including ensembles by"
						    " over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new"
						    " single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small"
						    " fraction of the training costs of the best models from the literature. We show that the Transformer"
						    " generalizes well to other tasks by applying it successfully to English constituency parsing both with"
						    " large and limited training data."  ,				candidate_labels=["machine learning", "statistics", "translation", "vision"]  ,				multi_label=__lowerCamelCase  ,				)
						self.assertEqual(
						    nested_simplify(__lowerCamelCase   )  ,				{
						        "sequence": (
						            "The dominant sequence transduction models are based on complex recurrent or convolutional neural"
						            " networks in an encoder-decoder configuration. The best performing models also connect the"
						            " encoder and decoder through an attention mechanism. We propose a new simple network"
						            " architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence"
						            " and convolutions entirely. Experiments on two machine translation tasks show these models to be"
						            " superior in quality while being more parallelizable and requiring significantly less time to"
						            " train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,"
						            " improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014"
						            " English-to-French translation task, our model establishes a new single-model state-of-the-art"
						            " BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training"
						            " costs of the best models from the literature. We show that the Transformer generalizes well to"
						            " other tasks by applying it successfully to English constituency parsing both with large and"
						            " limited training data."
						        ),
						        "labels": ["translation", "machine learning", "vision", "statistics"],
						        "scores": [0.8_1_7, 0.7_1_3, 0.0_1_8, 0.0_1_8],
						    }  ,				)







'''simple docstring'''



def 			SCREAMING_SNAKE_CASE_			(							__A    :			int  )			->			int:
   if n == 1 or not isinstance(__A	,					__A  ):
      return 0
   elif n == 2:
      return 1
   else:
      _SCREAMING_SNAKE_CASE	=				[0, 1]
      for i in range(2	,					n + 1  ):
         sequence.append(sequence[i - 1] + sequence[i - 2]  )

      return sequence[n]
def 			SCREAMING_SNAKE_CASE_			(							__A    :			int  )			->			int:
   _SCREAMING_SNAKE_CASE	=				0
   _SCREAMING_SNAKE_CASE	=				2

   while digits < n:
      index += 1
      _SCREAMING_SNAKE_CASE	=				len(str(fibonacci(__A  )  )  )

   return index
def 			SCREAMING_SNAKE_CASE_			(							__A    :			int = 10_00  )			->			int:
   return fibonacci_digits_index(__A  )


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

