import inspect
import unittest
from typing import List

import numpy as np

from transformers import EfficientFormerConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
      import tensorflow as tf

      from transformers import (
          TFEfficientFormerForImageClassification,
          TFEfficientFormerForImageClassificationWithTeacher,
          TFEfficientFormerModel,
      )
      from transformers.models.efficientformer.modeling_tf_efficientformer import (
          TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
      )


if is_vision_available():
      from PIL import Image

      from transformers import EfficientFormerImageProcessor


class      lowerCamelCase    :
  """simple docstring"""







  def __init__(							self       :				List[str]     ,   __magic_name__       :				Optional[int]     ,   __magic_name__       :				int = 13     ,   __magic_name__       :				int = 64     ,   __magic_name__       :				int = 2     ,   __magic_name__       :				int = 3     ,   __magic_name__       :				int = 3     ,   __magic_name__       :				bool = True     ,   __magic_name__       :				bool = True     ,   __magic_name__       :				int = 128     ,   __magic_name__       :				str=[16, 32, 64, 128]     ,   __magic_name__       :				int = 7     ,   __magic_name__       :				int = 4     ,   __magic_name__       :				int = 37     ,   __magic_name__       :				str = "gelu"     ,   __magic_name__       :				float = 0.1     ,   __magic_name__       :				float = 0.1     ,   __magic_name__       :				int = 10     ,   __magic_name__       :				float = 0.02     ,   __magic_name__       :				int = 2     ,   __magic_name__       :				int = 1     ,   __magic_name__       :				int = 128     ,   __magic_name__       :				List[int] = [2, 2, 2, 2]     ,   __magic_name__       :				int = 2     ,   __magic_name__       :				int = 2     ,   )     ->		Optional[Any]:
        SCREAMING_SNAKE_CASE_      =     parent
        SCREAMING_SNAKE_CASE_      =     batch_size
        SCREAMING_SNAKE_CASE_      =     image_size
        SCREAMING_SNAKE_CASE_      =     patch_size
        SCREAMING_SNAKE_CASE_      =     num_channels
        SCREAMING_SNAKE_CASE_      =     is_training
        SCREAMING_SNAKE_CASE_      =     use_labels
        SCREAMING_SNAKE_CASE_      =     hidden_size
        SCREAMING_SNAKE_CASE_      =     num_hidden_layers
        SCREAMING_SNAKE_CASE_      =     num_attention_heads
        SCREAMING_SNAKE_CASE_      =     intermediate_size
        SCREAMING_SNAKE_CASE_      =     hidden_act
        SCREAMING_SNAKE_CASE_      =     hidden_dropout_prob
        SCREAMING_SNAKE_CASE_      =     attention_probs_dropout_prob
        SCREAMING_SNAKE_CASE_      =     type_sequence_label_size
        SCREAMING_SNAKE_CASE_      =     initializer_range
        SCREAMING_SNAKE_CASE_      =     encoder_stride
        SCREAMING_SNAKE_CASE_      =     num_attention_outputs
        SCREAMING_SNAKE_CASE_      =     embed_dim
        SCREAMING_SNAKE_CASE_      =     embed_dim + 1
        SCREAMING_SNAKE_CASE_      =     resolution
        SCREAMING_SNAKE_CASE_      =     depths
        SCREAMING_SNAKE_CASE_      =     hidden_sizes
        SCREAMING_SNAKE_CASE_      =     dim
        SCREAMING_SNAKE_CASE_      =     mlp_expansion_ratio







  def       __A   (							self       :				int      )     ->		Dict:
        SCREAMING_SNAKE_CASE_      =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

        SCREAMING_SNAKE_CASE_      =     None
        if self.use_labels:
              SCREAMING_SNAKE_CASE_      =     ids_tensor([self.batch_size]     ,   self.type_sequence_label_size      )

        SCREAMING_SNAKE_CASE_      =     self.get_config()

        return config, pixel_values, labels







  def       __A   (							self       :				List[Any]      )     ->		Tuple:
        return EfficientFormerConfig(
            image_size=self.image_size     ,   patch_size=self.patch_size     ,   num_channels=self.num_channels     ,   hidden_size=self.hidden_size     ,   num_hidden_layers=self.num_hidden_layers     ,   num_attention_heads=self.num_attention_heads     ,   intermediate_size=self.intermediate_size     ,   hidden_act=self.hidden_act     ,   hidden_dropout_prob=self.hidden_dropout_prob     ,   attention_probs_dropout_prob=self.attention_probs_dropout_prob     ,   is_decoder=__magic_name__     ,   initializer_range=self.initializer_range     ,   encoder_stride=self.encoder_stride     ,   resolution=self.resolution     ,   depths=self.depths     ,   hidden_sizes=self.hidden_sizes     ,   dim=self.dim     ,   mlp_expansion_ratio=self.mlp_expansion_ratio     ,   )







  def       __A   (							self       :				Dict     ,   __magic_name__       :				int     ,   __magic_name__       :				List[str]     ,   __magic_name__       :				Tuple      )     ->		Union[str, Any]:
        SCREAMING_SNAKE_CASE_      =     TFEfficientFormerModel(config=__magic_name__      )
        SCREAMING_SNAKE_CASE_      =     model(__magic_name__     ,   training=__magic_name__      )
        self.parent.assertEqual(result.last_hidden_state.shape     ,   (self.batch_size, self.seq_length, self.hidden_size)      )







  def       __A   (							self       :				Optional[Any]     ,   __magic_name__       :				Optional[int]     ,   __magic_name__       :				List[str]     ,   __magic_name__       :				Any      )     ->		List[str]:
        SCREAMING_SNAKE_CASE_      =     self.type_sequence_label_size
        SCREAMING_SNAKE_CASE_      =     TFEfficientFormerForImageClassification(__magic_name__      )
        SCREAMING_SNAKE_CASE_      =     model(__magic_name__     ,   labels=__magic_name__     ,   training=__magic_name__      )
        self.parent.assertEqual(result.logits.shape     ,   (self.batch_size, self.type_sequence_label_size)      )

        # test greyscale images
        SCREAMING_SNAKE_CASE_      =     1
        SCREAMING_SNAKE_CASE_      =     TFEfficientFormerForImageClassification(__magic_name__      )

        SCREAMING_SNAKE_CASE_      =     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]      )
        SCREAMING_SNAKE_CASE_      =     model(__magic_name__     ,   labels=__magic_name__      )
        self.parent.assertEqual(result.logits.shape     ,   (self.batch_size, self.type_sequence_label_size)      )







  def       __A   (							self       :				List[Any]      )     ->		List[Any]:
        SCREAMING_SNAKE_CASE_      =     self.prepare_config_and_inputs()
        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     config_and_inputs
        SCREAMING_SNAKE_CASE_      =     {"pixel_values": pixel_values}
        return config, inputs_dict



@require_tf
class      lowerCamelCase    (SCREAMING_SNAKE_CASE__     ,					SCREAMING_SNAKE_CASE__     ,					unittest.TestCase    ):
  """simple docstring"""







  lowerCamelCase__   =  (
      (
          TFEfficientFormerModel,
          TFEfficientFormerForImageClassificationWithTeacher,
          TFEfficientFormerForImageClassification,
      )
      if is_tf_available()
      else ()
  )
  lowerCamelCase__   =  (
      {
          '''feature-extraction''': TFEfficientFormerModel,
          '''image-classification''': (
              TFEfficientFormerForImageClassification,
              TFEfficientFormerForImageClassificationWithTeacher,
          ),
      }
      if is_tf_available()
      else {}
  )

  lowerCamelCase__   =  False

  lowerCamelCase__   =  False
  lowerCamelCase__   =  False
  lowerCamelCase__   =  False
  lowerCamelCase__   =  False







  def       __A   (							self       :				Any      )     ->		List[str]:
        SCREAMING_SNAKE_CASE_      =     TFEfficientFormerModelTester(self      )
        SCREAMING_SNAKE_CASE_      =     ConfigTester(
            self     ,   config_class=__magic_name__     ,   has_text_modality=__magic_name__     ,   hidden_size=37      )







  def       __A   (							self       :				int      )     ->		Tuple:
        self.config_tester.run_common_tests()







  @unittest.skip(reason="EfficientFormer does not use inputs_embeds"      )
  def       __A   (							self       :				Dict      )     ->		Dict:
        pass







  @unittest.skip(reason="EfficientFormer does not support input and output embeddings"      )
  def       __A   (							self       :				Union[str, Any]      )     ->		Union[str, Any]:
        pass







  def       __A   (							self       :				Optional[int]      )     ->		int:
        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE_      =     model_class(__magic_name__      )
              SCREAMING_SNAKE_CASE_      =     inspect.signature(model.call      )
              # signature.parameters is an OrderedDict => so arg_names order is deterministic
              SCREAMING_SNAKE_CASE_      =     [*signature.parameters.keys()]

              SCREAMING_SNAKE_CASE_      =     ["pixel_values"]
              self.assertListEqual(arg_names[:1]     ,   __magic_name__      )







  def       __A   (							self       :				List[str]      )     ->		Dict:
        def check_hidden_states_output(__magic_name__       :				Dict     ,   __magic_name__       :				int     ,   __magic_name__       :				List[str]      ):
              SCREAMING_SNAKE_CASE_      =     model_class(__magic_name__      )

              SCREAMING_SNAKE_CASE_      =     model(**self._prepare_for_class(__magic_name__     ,   __magic_name__      )     ,   training=__magic_name__      )
              SCREAMING_SNAKE_CASE_      =     outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

              SCREAMING_SNAKE_CASE_      =     getattr(
                  self.model_tester     ,   "expected_num_hidden_layers"     ,   self.model_tester.num_hidden_layers + 1      )
              self.assertEqual(len(__magic_name__      )     ,   __magic_name__      )

              if hasattr(self.model_tester     ,   "encoder_seq_length"      ):
                    SCREAMING_SNAKE_CASE_      =     self.model_tester.encoder_seq_length
                    if hasattr(self.model_tester     ,   "chunk_length"      ) and self.model_tester.chunk_length > 1:
                          SCREAMING_SNAKE_CASE_      =     seq_length * self.model_tester.chunk_length
              else:
                    SCREAMING_SNAKE_CASE_      =     self.model_tester.seq_length

              self.assertListEqual(
                  list(hidden_states[-1].shape[-2:]      )     ,   [seq_length, self.model_tester.hidden_size]     ,   )

              if config.is_encoder_decoder:
                    SCREAMING_SNAKE_CASE_      =     outputs.decoder_hidden_states

                    self.asseretIsInstance(__magic_name__     ,   (list, tuple)      )
                    self.assertEqual(len(__magic_name__      )     ,   __magic_name__      )
                    SCREAMING_SNAKE_CASE_      =     getattr(self.model_tester     ,   "seq_length"     ,   __magic_name__      )
                    SCREAMING_SNAKE_CASE_      =     getattr(self.model_tester     ,   "decoder_seq_length"     ,   __magic_name__      )

                    self.assertListEqual(
                        list(hidden_states[-1].shape[-2:]      )     ,   [decoder_seq_length, self.model_tester.hidden_size]     ,   )

        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE_      =     True
              check_hidden_states_output(__magic_name__     ,   __magic_name__     ,   __magic_name__      )

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              SCREAMING_SNAKE_CASE_      =     True

              check_hidden_states_output(__magic_name__     ,   __magic_name__     ,   __magic_name__      )







  def       __A   (							self       :				Optional[int]     ,   __magic_name__       :				Tuple     ,   __magic_name__       :				List[str]     ,   __magic_name__       :				int=False      )     ->		Optional[Any]:
        SCREAMING_SNAKE_CASE_      =     super()._prepare_for_class(__magic_name__     ,   __magic_name__     ,   return_labels=__magic_name__      )

        if return_labels:
              if model_class.__name__ == "TFEfficientFormerForImageClassificationWithTeacher":
                    del inputs_dict["labels"]

        return inputs_dict







  def       __A   (							self       :				Tuple      )     ->		Any:
        SCREAMING_SNAKE_CASE_      =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__magic_name__      )







  @unittest.skip(reason="EfficientFormer does not implement masked image modeling yet"      )
  def       __A   (							self       :				List[Any]      )     ->		Union[str, Any]:
        SCREAMING_SNAKE_CASE_      =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_image_modeling(*__magic_name__      )







  def       __A   (							self       :				List[str]      )     ->		Any:
        SCREAMING_SNAKE_CASE_      =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*__magic_name__      )







  @slow
  def       __A   (							self       :				Tuple      )     ->		Optional[Any]:
        for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              SCREAMING_SNAKE_CASE_      =     TFEfficientFormerModel.from_pretrained(__magic_name__      )
              self.assertIsNotNone(__magic_name__      )







  def       __A   (							self       :				Optional[int]      )     ->		Tuple:
        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     self.model_tester.prepare_config_and_inputs_for_common()
        SCREAMING_SNAKE_CASE_      =     True

        SCREAMING_SNAKE_CASE_      =     getattr(self.model_tester     ,   "seq_length"     ,   __magic_name__      )
        SCREAMING_SNAKE_CASE_      =     getattr(self.model_tester     ,   "encoder_seq_length"     ,   __magic_name__      )
        SCREAMING_SNAKE_CASE_      =     getattr(self.model_tester     ,   "key_length"     ,   __magic_name__      )
        SCREAMING_SNAKE_CASE_      =     getattr(self.model_tester     ,   "chunk_length"     ,   __magic_name__      )

        if chunk_length is not None and hasattr(self.model_tester     ,   "num_hashes"      ):
              SCREAMING_SNAKE_CASE_      =     encoder_seq_length * self.model_tester.num_hashes

        for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE_      =     True
              SCREAMING_SNAKE_CASE_      =     False
              SCREAMING_SNAKE_CASE_      =     True
              SCREAMING_SNAKE_CASE_      =     model_class(__magic_name__      )

              SCREAMING_SNAKE_CASE_      =     model(**self._prepare_for_class(__magic_name__     ,   __magic_name__      )     ,   training=__magic_name__      )
              SCREAMING_SNAKE_CASE_      =     outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
              self.assertEqual(len(__magic_name__      )     ,   self.model_tester.num_attention_outputs      )

              # check that output_attentions also work using config
              del inputs_dict["output_attentions"]
              SCREAMING_SNAKE_CASE_      =     True
              SCREAMING_SNAKE_CASE_      =     model_class(__magic_name__      )
              SCREAMING_SNAKE_CASE_      =     model(**self._prepare_for_class(__magic_name__     ,   __magic_name__      )     ,   training=__magic_name__      )

              SCREAMING_SNAKE_CASE_      =     outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
              self.assertEqual(len(__magic_name__      )     ,   self.model_tester.num_attention_outputs      )

              if chunk_length is not None:
                    self.assertListEqual(
                        list(attentions[0].shape[-4:]      )     ,   [self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]     ,   )
              else:
                    self.assertListEqual(
                        list(attentions[0].shape[-3:]      )     ,   [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]     ,   )







  def       __A   (							self       :				Union[str, Any]      )     ->		List[str]:
        # We use a simplified version of this test for EfficientFormer because it requires training=False
        # and Keras refuses to let us force that during functional construction
        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
              # Prepare our model
              SCREAMING_SNAKE_CASE_      =     model_class(__magic_name__      )
              # These are maximally general inputs for the model, with multiple None dimensions
              # Hopefully this will catch any conditionals that fail for flexible shapes
              SCREAMING_SNAKE_CASE_      =     {
                  key: tf.keras.Input(shape=val.shape[1:]     ,   dtype=val.dtype     ,   name=__magic_name__      )
                  for key, val in model.input_signature.items()
                  if key in model.dummy_inputs
              }
              SCREAMING_SNAKE_CASE_      =     model(__magic_name__      )
              self.assertTrue(outputs_dict is not None      )



def    a__       (						):
      SCREAMING_SNAKE_CASE_      =     Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" )
      return image





@require_tf
@require_vision
class      lowerCamelCase    (unittest.TestCase    ):
  """simple docstring"""







  @cached_property
  def       __A   (							self       :				Optional[int]      )     ->		int:
        return (
            EfficientFormerImageProcessor.from_pretrained("snap-research/efficientformer-l1-300"      )
            if is_vision_available()
            else None
        )







  @slow
  def       __A   (							self       :				Optional[Any]      )     ->		Dict:
        SCREAMING_SNAKE_CASE_      =     TFEfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300"      )
        SCREAMING_SNAKE_CASE_      =     self.default_image_processor
        SCREAMING_SNAKE_CASE_      =     prepare_img()
        SCREAMING_SNAKE_CASE_      =     image_processor(images=__magic_name__     ,   return_tensors="tf"      )
        # forward pass
        SCREAMING_SNAKE_CASE_      =     model(**__magic_name__     ,   training=__magic_name__      )
        # verify the logits
        SCREAMING_SNAKE_CASE_      =     tf.TensorShape((1, 1_000)      )
        self.assertEqual(outputs.logits.shape     ,   __magic_name__      )
        SCREAMING_SNAKE_CASE_      =     tf.constant([-0.0555, 0.4825, -0.0852]      )
        self.assertTrue(np.allclose(outputs.logits[0, :3]     ,   __magic_name__     ,   atol=1e-4      )      )







  @slow
  def       __A   (							self       :				int      )     ->		List[str]:
        SCREAMING_SNAKE_CASE_      =     TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
            "snap-research/efficientformer-l1-300"      )
        SCREAMING_SNAKE_CASE_      =     self.default_image_processor
        SCREAMING_SNAKE_CASE_      =     prepare_img()
        SCREAMING_SNAKE_CASE_      =     image_processor(images=__magic_name__     ,   return_tensors="tf"      )
        # forward pass
        SCREAMING_SNAKE_CASE_      =     model(**__magic_name__     ,   training=__magic_name__      )
        # verify the logits
        SCREAMING_SNAKE_CASE_      =     tf.TensorShape((1, 1_000)      )
        self.assertEqual(outputs.logits.shape     ,   __magic_name__      )
        SCREAMING_SNAKE_CASE_      =     tf.constant([-0.1312, 0.4353, -1.0499]      )
        self.assertTrue(np.allclose(outputs.logits[0, :3]     ,   __magic_name__     ,   atol=1e-4      )      )



def    a__       (						__UpperCamelCase ):
      if n == 1 or not isinstance(__UpperCamelCase   ,					__UpperCamelCase ):
            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    a__       (						__UpperCamelCase ):
      SCREAMING_SNAKE_CASE_      =     0
      SCREAMING_SNAKE_CASE_      =     2

      while digits < n:
            index += 1
            SCREAMING_SNAKE_CASE_      =     len(str(fibonacci(__UpperCamelCase ) ) )

      return index


def    a__       (						__UpperCamelCase = 1_0_0_0 ):
      return fibonacci_digits_index(__UpperCamelCase )


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


