






"""simple docstring"""




import copy
import inspect

from transformers.testing_utils import require_torch, torch_device
from transformers.utils.backbone_utils import BackboneType






@require_torch
class  UpperCamelCase    :
 UpperCamelCase      : int    =      ()
 UpperCamelCase      : Optional[Any]    =      True


 def _lowercase			(  self	:		List[Any]							)      -> Tuple:
   _a						: Any    =			self.config_class

   # test default config
   _a						: Optional[int]    =			config_class()
   self.assertIsNotNone(UpperCAmelCase__							)
   _a						: List[str]    =			["""stem"""] + [f"""stage{idx}""" for idx in range(1							,		len(config.depths							) + 1							)]
   self.assertEqual(config.stage_names							,		UpperCAmelCase__							)
   self.assertTrue(set(config.out_features							).issubset(set(config.stage_names							)							)							)

   # Test out_features and out_indices are correctly set
   # out_features and out_indices both None
   _a						: Union[str, Any]    =			config_class(out_features=UpperCAmelCase__							,		out_indices=UpperCAmelCase__							)
   self.assertEqual(config.out_features							,		[config.stage_names[-1]]							)
   self.assertEqual(config.out_indices							,		[len(config.stage_names							) - 1]							)

   # out_features and out_indices both set
   _a						: str    =			config_class(out_features=["""stem""", """stage1"""]							,		out_indices=[0, 1]							)
   self.assertEqual(config.out_features							,		["""stem""", """stage1"""]							)
   self.assertEqual(config.out_indices							,		[0, 1]							)

   # Only out_features set
   _a						: Tuple    =			config_class(out_features=["""stage1""", """stage3"""]							)
   self.assertEqual(config.out_features							,		["""stage1""", """stage3"""]							)
   self.assertEqual(config.out_indices							,		[1, 3]							)

   # Only out_indices set
   _a						: Union[str, Any]    =			config_class(out_indices=[0, 2]							)
   self.assertEqual(config.out_features							,		[config.stage_names[0], config.stage_names[2]]							)
   self.assertEqual(config.out_indices							,		[0, 2]							)

   # Error raised when out_indices do not correspond to out_features
   with self.assertRaises(UpperCAmelCase__							):
     _a						: Optional[Any]    =			config_class(out_features=["""stage1""", """stage2"""]							,		out_indices=[0, 2]							)


 def _lowercase			(  self	:		Any							)      -> Optional[int]:
   _a   ,						_a						: Union[str, Any]    =			self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
     _a						: Union[str, Any]    =			model_class(UpperCAmelCase__							)
     _a						: Dict    =			inspect.signature(model.forward							)
     # signature.parameters is an OrderedDict => so arg_names order is deterministic
     _a						: Optional[int]    =			[*signature.parameters.keys()]
     _a						: List[str]    =			["""pixel_values"""]
     self.assertListEqual(arg_names[:1]							,		UpperCAmelCase__							)


 def _lowercase			(  self	:		List[str]							)      -> Dict:
   _a   ,						_a						: Optional[Any]    =			self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
     _a						: Union[str, Any]    =			model_class(UpperCAmelCase__							)
     self.assertEqual(len(model.channels							)							,		len(config.out_features							)							)
     _a						: Tuple    =			model.num_features
     _a						: Dict    =			[config.stage_names.index(UpperCAmelCase__							) for feat in config.out_features]
     _a						: Dict    =			[num_features[idx] for idx in out_indices]
     self.assertListEqual(model.channels							,		UpperCAmelCase__							)

     _a						: List[str]    =			copy.deepcopy(UpperCAmelCase__							)
     _a						: Union[str, Any]    =			None
     _a						: Optional[Any]    =			model_class(UpperCAmelCase__							)
     self.assertEqual(len(model.channels							)							,		1							)
     self.assertListEqual(model.channels							,		[num_features[-1]]							)

     _a						: Union[str, Any]    =			copy.deepcopy(UpperCAmelCase__							)
     _a						: Optional[Any]    =			None
     _a						: List[str]    =			model_class(UpperCAmelCase__							)
     self.assertEqual(len(model.channels							)							,		1							)
     self.assertListEqual(model.channels							,		[num_features[-1]]							)


 def _lowercase			(  self	:		List[str]							)      -> Optional[Any]:
   _a   ,						_a						: Optional[Any]    =			self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
     _a						: Union[str, Any]    =			model_class(UpperCAmelCase__							)
     model.to(UpperCAmelCase__							)
     model.eval()
     _a						: int    =			model(**UpperCAmelCase__							)

     self.assertEqual(len(result.feature_maps							)							,		len(config.out_features							)							)
     self.assertEqual(len(model.channels							)							,		len(config.out_features							)							)
     self.assertEqual(len(result.feature_maps							)							,		len(config.out_indices							)							)
     self.assertEqual(len(model.channels							)							,		len(config.out_indices							)							)

     # Check output of last stage is taken if out_features=None, out_indices=None
     _a						: List[str]    =			copy.deepcopy(UpperCAmelCase__							)
     _a						: List[str]    =			None
     _a						: int    =			model_class(UpperCAmelCase__							)
     model.to(UpperCAmelCase__							)
     model.eval()
     _a						: Optional[Any]    =			model(**UpperCAmelCase__							)

     self.assertEqual(len(result.feature_maps							)							,		1							)
     self.assertEqual(len(model.channels							)							,		1							)

     _a						: List[str]    =			copy.deepcopy(UpperCAmelCase__							)
     _a						: Tuple    =			None
     _a						: int    =			model_class(UpperCAmelCase__							)
     model.to(UpperCAmelCase__							)
     model.eval()
     _a						: Optional[int]    =			model(**UpperCAmelCase__							)

     self.assertEqual(len(result.feature_maps							)							,		1							)
     self.assertEqual(len(model.channels							)							,		1							)

     # Check backbone can be initialized with fresh weights
     _a						: Optional[int]    =			copy.deepcopy(UpperCAmelCase__							)
     _a						: List[Any]    =			False
     _a						: str    =			model_class(UpperCAmelCase__							)
     model.to(UpperCAmelCase__							)
     model.eval()
     _a						: Union[str, Any]    =			model(**UpperCAmelCase__							)


 def _lowercase			(  self	:		Union[str, Any]							)      -> Tuple:
   _a   ,						_a						: Dict    =			self.model_tester.prepare_config_and_inputs_for_common()

   for backbone_class in self.all_model_classes:
     _a						: Dict    =			backbone_class(UpperCAmelCase__							)

     self.assertTrue(hasattr(UpperCAmelCase__							,		"""backbone_type"""							)							)
     self.assertTrue(hasattr(UpperCAmelCase__							,		"""stage_names"""							)							)
     self.assertTrue(hasattr(UpperCAmelCase__							,		"""num_features"""							)							)
     self.assertTrue(hasattr(UpperCAmelCase__							,		"""out_indices"""							)							)
     self.assertTrue(hasattr(UpperCAmelCase__							,		"""out_features"""							)							)
     self.assertTrue(hasattr(UpperCAmelCase__							,		"""out_feature_channels"""							)							)
     self.assertTrue(hasattr(UpperCAmelCase__							,		"""channels"""							)							)

     self.assertIsInstance(backbone.backbone_type							,		UpperCAmelCase__							)
     # Verify num_features has been initialized in the backbone init
     self.assertIsNotNone(backbone.num_features							)
     self.assertTrue(len(backbone.channels							) == len(backbone.out_indices							)							)
     self.assertTrue(len(backbone.stage_names							) == len(backbone.num_features							)							)
     self.assertTrue(len(backbone.channels							) <= len(backbone.num_features							)							)
     self.assertTrue(len(backbone.out_feature_channels							) == len(backbone.stage_names							)							)







 def _lowercase			(  self	:		Any							)      -> Dict:
   _a   ,						_a						: str    =			self.model_tester.prepare_config_and_inputs_for_common()
   _a						: Optional[int]    =			inputs_dict["""pixel_values"""].shape[0]

   for backbone_class in self.all_model_classes:
     _a						: Dict    =			backbone_class(UpperCAmelCase__							)
     backbone.to(UpperCAmelCase__							)
     backbone.eval()

     _a						: Union[str, Any]    =			backbone(**UpperCAmelCase__							)

     # Test default outputs and verify feature maps
     self.assertIsInstance(outputs.feature_maps							,		UpperCAmelCase__							)
     self.assertTrue(len(outputs.feature_maps							) == len(backbone.channels							)							)
     for feature_map, n_channels in zip(outputs.feature_maps							,		backbone.channels							):
       self.assertTrue(feature_map.shape[:2]							,		(batch_size, n_channels)							)
     self.assertIsNone(outputs.hidden_states							)
     self.assertIsNone(outputs.attentions							)

     # Test output_hidden_states=True
     _a						: Union[str, Any]    =			backbone(**UpperCAmelCase__							,		output_hidden_states=UpperCAmelCase__							)
     self.assertIsNotNone(outputs.hidden_states							)
     self.assertTrue(len(outputs.hidden_states							)							,		len(backbone.stage_names							)							)
     for hidden_state, n_channels in zip(outputs.hidden_states							,		backbone.channels							):
       self.assertTrue(hidden_state.shape[:2]							,		(batch_size, n_channels)							)

     # Test output_attentions=True
     if self.has_attentions:
       _a						: Optional[Any]    =			backbone(**UpperCAmelCase__							,		output_attentions=UpperCAmelCase__							)
       self.assertIsNotNone(outputs.attentions							)









"""simple docstring"""




from __future__ import annotations

import sys

def     lowerCAmelCase__  (  UpperCamelCase__       ):



  '''simple docstring'''
  if n < 0:
    raise ValueError("""Negative arguments are not supported"""       )
  return _fib(UpperCamelCase__       )[0]

def     lowerCAmelCase__  (  UpperCamelCase__       ):



  '''simple docstring'''
  if n == 0:  # (F(0), F(1))
    return (0, 1)

  # F(2n) = F(n)[2F(n+1) − F(n)]
  # F(2n+1) = F(n+1)^2+F(n)^2
  _a   ,						_a						: Dict    =			_fib(n // 2       )
  _a						: Dict    =			a * (b * 2 - a)
  _a						: Optional[Any]    =			a * a + b * b
  return (d, c + d) if n % 2 else (c, d)


if __name__ == "__main__":
 _snake_case					   =     int(sys.argv[1])
 print(F'''fibonacci({n}) is {fibonacci(n)}''')

