from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import RegNetConfig
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 TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFRegNetForImageClassification, TFRegNetModel


if is_vision_available():
      from PIL import Image

      from transformers import AutoImageProcessor





class 					A							:


   def __init__(self					:						List[str]	,  __UpperCAmelCase					:						Any	,  __UpperCAmelCase					:						int=3	,  __UpperCAmelCase					:						Optional[int]=3_2	,  __UpperCAmelCase					:						Any=3	,  __UpperCAmelCase					:						Dict=1_0	,  __UpperCAmelCase					:						int=[1_0, 2_0, 3_0, 4_0]	,  __UpperCAmelCase					:						List[str]=[1, 1, 2, 1]	,  __UpperCAmelCase					:						Tuple=True	,  __UpperCAmelCase					:						List[str]=True	,  __UpperCAmelCase					:						Optional[Any]="relu"	,  __UpperCAmelCase					:						Any=3	,  __UpperCAmelCase					:						Union[str, Any]=None	,  )						->    int:
         """simple docstring"""



         UpperCAmelCase__								=  parent
         UpperCAmelCase__								=  batch_size
         UpperCAmelCase__								=  image_size
         UpperCAmelCase__								=  num_channels
         UpperCAmelCase__								=  embeddings_size
         UpperCAmelCase__								=  hidden_sizes
         UpperCAmelCase__								=  depths
         UpperCAmelCase__								=  is_training
         UpperCAmelCase__								=  use_labels
         UpperCAmelCase__								=  hidden_act
         UpperCAmelCase__								=  num_labels
         UpperCAmelCase__								=  scope
         UpperCAmelCase__								=  len(__UpperCAmelCase		)


   def       lowercase_				(self					:						Tuple		)						->    Tuple:
         """simple docstring"""



         UpperCAmelCase__								=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

         UpperCAmelCase__								=  None
         if self.use_labels:
               UpperCAmelCase__								=  ids_tensor([self.batch_size]	,  self.num_labels		)

         UpperCAmelCase__								=  self.get_config()
         return config, pixel_values, labels


   def       lowercase_				(self					:						Dict		)						->    List[str]:
         """simple docstring"""



         return RegNetConfig(
             num_channels=self.num_channels	,  embeddings_size=self.embeddings_size	,  hidden_sizes=self.hidden_sizes	,  depths=self.depths	,  hidden_act=self.hidden_act	,  num_labels=self.num_labels	,  )


   def       lowercase_				(self					:						Any	,  __UpperCAmelCase					:						str	,  __UpperCAmelCase					:						List[Any]	,  __UpperCAmelCase					:						int		)						->    List[Any]:
         """simple docstring"""



         UpperCAmelCase__								=  TFRegNetModel(config=__UpperCAmelCase		)
         UpperCAmelCase__								=  model(__UpperCAmelCase	,  training=__UpperCAmelCase		)
         # expected last hidden states: B, C, H // 32, W // 32
         self.parent.assertEqual(
             result.last_hidden_state.shape	,  (self.batch_size, self.hidden_sizes[-1], self.image_size // 3_2, self.image_size // 3_2)	,  )


   def       lowercase_				(self					:						List[str]	,  __UpperCAmelCase					:						Optional[Any]	,  __UpperCAmelCase					:						Optional[int]	,  __UpperCAmelCase					:						Tuple		)						->    Optional[Any]:
         """simple docstring"""



         UpperCAmelCase__								=  self.num_labels
         UpperCAmelCase__								=  TFRegNetForImageClassification(__UpperCAmelCase		)
         UpperCAmelCase__								=  model(__UpperCAmelCase	,  labels=__UpperCAmelCase	,  training=__UpperCAmelCase		)
         self.parent.assertEqual(result.logits.shape	,  (self.batch_size, self.num_labels)		)





   def       lowercase_				(self					:						List[str]		)						->    List[Any]:
         """simple docstring"""



         UpperCAmelCase__								=  self.prepare_config_and_inputs()
         UpperCAmelCase__		,				UpperCAmelCase__		,				UpperCAmelCase__								=  config_and_inputs
         UpperCAmelCase__								=  {"pixel_values": pixel_values}
         return config, inputs_dict





@require_tf
class 					A							(    UpperCAmelCase_		,    UpperCAmelCase_		,    unittest.TestCase					):
   __UpperCAmelCase			:			Dict              =      (TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
   __UpperCAmelCase			:			Tuple              =      (
       {'feature-extraction': TFRegNetModel, 'image-classification': TFRegNetForImageClassification}
       if is_tf_available()
       else {}
   )

   __UpperCAmelCase			:			Optional[int]              =      False
   __UpperCAmelCase			:			List[str]              =      False
   __UpperCAmelCase			:			Optional[int]              =      False
   __UpperCAmelCase			:			str              =      False
   __UpperCAmelCase			:			Optional[int]              =      False


   def       lowercase_				(self					:						List[str]		)						->    Tuple:
         """simple docstring"""



         UpperCAmelCase__								=  TFRegNetModelTester(self		)
         UpperCAmelCase__								=  ConfigTester(self	,  config_class=__UpperCAmelCase	,  has_text_modality=__UpperCAmelCase		)


   def       lowercase_				(self					:						Any		)						->    Optional[Any]:
         """simple docstring"""



         return


   @unittest.skip(reason="RegNet does not use inputs_embeds"		)
   def       lowercase_				(self					:						Optional[Any]		)						->    Optional[Any]:
         """simple docstring"""



         pass


   @unittest.skipIf(
       not is_tf_available() or len(tf.config.list_physical_devices("GPU"		)		) == 0	,  reason="TF does not support backprop for grouped convolutions on CPU."	,  )
   @slow
   def       lowercase_				(self					:						Tuple		)						->    Tuple:
         """simple docstring"""



         super().test_keras_fit()


   @unittest.skip(reason="RegNet does not support input and output embeddings"		)
   def       lowercase_				(self					:						Optional[int]		)						->    Union[str, Any]:
         """simple docstring"""



         pass


   def       lowercase_				(self					:						List[Any]		)						->    Any:
         """simple docstring"""



         UpperCAmelCase__		,				UpperCAmelCase__								=  self.model_tester.prepare_config_and_inputs_for_common()

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

               UpperCAmelCase__								=  ["pixel_values"]
               self.assertListEqual(arg_names[:1]	,  __UpperCAmelCase		)


   def       lowercase_				(self					:						Any		)						->    Optional[int]:
         """simple docstring"""



         UpperCAmelCase__								=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__UpperCAmelCase		)


   def       lowercase_				(self					:						int		)						->    str:
         """simple docstring"""



         def check_hidden_states_output(__UpperCAmelCase					:						str	,  __UpperCAmelCase					:						int	,  __UpperCAmelCase					:						List[str]		):
               UpperCAmelCase__								=  model_class(__UpperCAmelCase		)
               UpperCAmelCase__								=  model(**self._prepare_for_class(__UpperCAmelCase	,  __UpperCAmelCase		)	,  training=__UpperCAmelCase		)

               UpperCAmelCase__								=  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

               UpperCAmelCase__								=  self.model_tester.num_stages
               self.assertEqual(len(__UpperCAmelCase		)	,  expected_num_stages + 1		)

               # RegNet's feature maps are of shape (batch_size, num_channels, height, width)
               self.assertListEqual(
                   list(hidden_states[0].shape[-2:]		)	,  [self.model_tester.image_size // 2, self.model_tester.image_size // 2]	,  )

         UpperCAmelCase__		,				UpperCAmelCase__								=  self.model_tester.prepare_config_and_inputs_for_common()
         UpperCAmelCase__								=  ["basic", "bottleneck"]
         for model_class in self.all_model_classes:
               for layer_type in layers_type:
                     UpperCAmelCase__								=  layer_type
                     UpperCAmelCase__								=  True
                     check_hidden_states_output(__UpperCAmelCase	,  __UpperCAmelCase	,  __UpperCAmelCase		)

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

                     check_hidden_states_output(__UpperCAmelCase	,  __UpperCAmelCase	,  __UpperCAmelCase		)


   def       lowercase_				(self					:						Optional[int]		)						->    str:
         """simple docstring"""



         UpperCAmelCase__		,				UpperCAmelCase__								=  self.model_tester.prepare_config_and_inputs_for_common()

         def check_equivalence(__UpperCAmelCase					:						int	,  __UpperCAmelCase					:						List[Any]	,  __UpperCAmelCase					:						Optional[Any]	,  __UpperCAmelCase					:						Optional[Any]={}		):
               UpperCAmelCase__								=  model(__UpperCAmelCase	,  return_dict=__UpperCAmelCase	,  **__UpperCAmelCase		)
               UpperCAmelCase__								=  model(__UpperCAmelCase	,  return_dict=__UpperCAmelCase	,  **__UpperCAmelCase		).to_tuple()

               def recursive_check(__UpperCAmelCase					:						Union[str, Any]	,  __UpperCAmelCase					:						Union[str, Any]		):
                     if isinstance(__UpperCAmelCase	,  (List, Tuple)		):
                           for tuple_iterable_value, dict_iterable_value in zip(__UpperCAmelCase	,  __UpperCAmelCase		):
                                 recursive_check(__UpperCAmelCase	,  __UpperCAmelCase		)
                     elif tuple_object is None:
                           return
                     else:
                           self.assertTrue(
                               all(tf.equal(__UpperCAmelCase	,  __UpperCAmelCase		)		)	,  msg=(
                                   "Tuple and dict output are not equal. Difference:"
                                   f""" {tf.math.reduce_max(tf.abs(tuple_object - dict_object		)		)}"""
                               )	,  )

                     recursive_check(__UpperCAmelCase	,  __UpperCAmelCase		)

         for model_class in self.all_model_classes:
               UpperCAmelCase__								=  model_class(__UpperCAmelCase		)

               UpperCAmelCase__								=  self._prepare_for_class(__UpperCAmelCase	,  __UpperCAmelCase		)
               UpperCAmelCase__								=  self._prepare_for_class(__UpperCAmelCase	,  __UpperCAmelCase		)
               check_equivalence(__UpperCAmelCase	,  __UpperCAmelCase	,  __UpperCAmelCase		)

               UpperCAmelCase__								=  self._prepare_for_class(__UpperCAmelCase	,  __UpperCAmelCase	,  return_labels=__UpperCAmelCase		)
               UpperCAmelCase__								=  self._prepare_for_class(__UpperCAmelCase	,  __UpperCAmelCase	,  return_labels=__UpperCAmelCase		)
               check_equivalence(__UpperCAmelCase	,  __UpperCAmelCase	,  __UpperCAmelCase		)

               UpperCAmelCase__								=  self._prepare_for_class(__UpperCAmelCase	,  __UpperCAmelCase		)
               UpperCAmelCase__								=  self._prepare_for_class(__UpperCAmelCase	,  __UpperCAmelCase		)
               check_equivalence(__UpperCAmelCase	,  __UpperCAmelCase	,  __UpperCAmelCase	,  {"output_hidden_states": True}		)

               UpperCAmelCase__								=  self._prepare_for_class(__UpperCAmelCase	,  __UpperCAmelCase	,  return_labels=__UpperCAmelCase		)
               UpperCAmelCase__								=  self._prepare_for_class(__UpperCAmelCase	,  __UpperCAmelCase	,  return_labels=__UpperCAmelCase		)
               check_equivalence(__UpperCAmelCase	,  __UpperCAmelCase	,  __UpperCAmelCase	,  {"output_hidden_states": True}		)


   def       lowercase_				(self					:						List[Any]		)						->    Any:
         """simple docstring"""



         UpperCAmelCase__								=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*__UpperCAmelCase		)





   @slow
   def       lowercase_				(self					:						Optional[int]		)						->    Dict:
         """simple docstring"""



         for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               UpperCAmelCase__								=  TFRegNetModel.from_pretrained(__UpperCAmelCase		)
               self.assertIsNotNone(__UpperCAmelCase		)




def        lowerCAmelCase_			(					)					->    List[Any]:







      '''simple docstring'''


      UpperCAmelCase__								=  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"							)
      return image







@require_tf
@require_vision
class 					A							(    unittest.TestCase					):


   @cached_property
   def       lowercase_				(self					:						Dict		)						->    Optional[Any]:
         """simple docstring"""



         return (
             AutoImageProcessor.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)
             if is_vision_available()
             else None
         )





   @slow
   def       lowercase_				(self					:						List[Any]		)						->    int:
         """simple docstring"""



         UpperCAmelCase__								=  TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)

         UpperCAmelCase__								=  self.default_image_processor
         UpperCAmelCase__								=  prepare_img()
         UpperCAmelCase__								=  image_processor(images=__UpperCAmelCase	,  return_tensors="tf"		)

         # forward pass
         UpperCAmelCase__								=  model(**__UpperCAmelCase	,  training=__UpperCAmelCase		)

         # verify the logits
         UpperCAmelCase__								=  tf.TensorShape((1, 1_0_0_0)		)
         self.assertEqual(outputs.logits.shape	,  __UpperCAmelCase		)

         UpperCAmelCase__								=  tf.constant([-0.4180, -1.5051, -3.4836]		)

         tf.debugging.assert_near(outputs.logits[0, :3]	,  __UpperCAmelCase	,  atol=1E-4		)
from __future__ import annotations




def        lowerCAmelCase_			(					__A							)					->    bool:







      '''simple docstring'''


      UpperCAmelCase__								=  str(__A							)
      return n == n[::-1]




def        lowerCAmelCase_			(					__A = 1_000_000							)					->    Optional[int]:







      '''simple docstring'''


      UpperCAmelCase__								=  0

      for i in range(1,  __A							):
            if is_palindrome(__A							) and is_palindrome(bin(__A							).split("b"							)[1]							):
                  total += i
      return total


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



