





import copy
import inspect

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

@require_torch
class 						__a							:
       __snake_case  :      Dict					=						()
       __snake_case  :      int					=						True



       def        A							(   self		:      str	):
           lowerCAmelCase_    :		Tuple 						=      self.config_class

           # test default config
           lowerCAmelCase_    :		str 						=      config_class()
           self.assertIsNotNone(UpperCAmelCase	)
           lowerCAmelCase_    :		int 						=      ['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
           lowerCAmelCase_    :		Dict 						=      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
           lowerCAmelCase_    :		List[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
           lowerCAmelCase_    :		Union[str, Any] 						=      config_class(out_features=["""stage1""", """stage3"""]	)
           self.assertEqual(config.out_features    ,	["""stage1""", """stage3"""]	)
           self.assertEqual(config.out_indices    ,	[1, 3]	)

           # Only out_indices set
           lowerCAmelCase_    :		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	):
               lowerCAmelCase_    :		Optional[int] 						=      config_class(out_features=["""stage1""", """stage2"""]    ,	out_indices=[0, 2]	)



       def        A							(   self		:      Optional[Any]	):
           lowerCAmelCase_    :		Dict 						=      self.model_tester.prepare_config_and_inputs_for_common()

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



       def        A							(   self		:      str	):
           lowerCAmelCase_    :		Union[str, Any] 						=      self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
               lowerCAmelCase_    :		int 						=      model_class(UpperCAmelCase	)
               self.assertEqual(len(model.channels	)    ,	len(config.out_features	)	)
               lowerCAmelCase_    :		Tuple 						=      model.num_features
               lowerCAmelCase_    :		List[Any] 						=      [config.stage_names.index(UpperCAmelCase	) for feat in config.out_features]
               lowerCAmelCase_    :		Optional[Any] 						=      [num_features[idx] for idx in out_indices]
               self.assertListEqual(model.channels    ,	UpperCAmelCase	)

               lowerCAmelCase_    :		List[Any] 						=      copy.deepcopy(UpperCAmelCase	)
               lowerCAmelCase_    :		List[Any] 						=      None
               lowerCAmelCase_    :		Any 						=      model_class(UpperCAmelCase	)
               self.assertEqual(len(model.channels	)    ,	1	)
               self.assertListEqual(model.channels    ,	[num_features[-1]]	)

               lowerCAmelCase_    :		str 						=      copy.deepcopy(UpperCAmelCase	)
               lowerCAmelCase_    :		Any 						=      None
               lowerCAmelCase_    :		Tuple 						=      model_class(UpperCAmelCase	)
               self.assertEqual(len(model.channels	)    ,	1	)
               self.assertListEqual(model.channels    ,	[num_features[-1]]	)



       def        A							(   self		:      Optional[Any]	):
           lowerCAmelCase_    :		Any 						=      self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
               lowerCAmelCase_    :		str 						=      model_class(UpperCAmelCase	)
               model.to(UpperCAmelCase	)
               model.eval()
               lowerCAmelCase_    :		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
               lowerCAmelCase_    :		Tuple 						=      copy.deepcopy(UpperCAmelCase	)
               lowerCAmelCase_    :		Any 						=      None
               lowerCAmelCase_    :		Any 						=      model_class(UpperCAmelCase	)
               model.to(UpperCAmelCase	)
               model.eval()
               lowerCAmelCase_    :		Dict 						=      model(**UpperCAmelCase	)

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

               lowerCAmelCase_    :		str 						=      copy.deepcopy(UpperCAmelCase	)
               lowerCAmelCase_    :		Dict 						=      None
               lowerCAmelCase_    :		Tuple 						=      model_class(UpperCAmelCase	)
               model.to(UpperCAmelCase	)
               model.eval()
               lowerCAmelCase_    :		List[str] 						=      model(**UpperCAmelCase	)

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

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



       def        A							(   self		:      List[str]	):
           lowerCAmelCase_    :		Optional[int] 						=      self.model_tester.prepare_config_and_inputs_for_common()

           for backbone_class in self.all_model_classes:
               lowerCAmelCase_    :		int 						=      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        A							(   self		:      List[str]	):
           lowerCAmelCase_    :		Any 						=      self.model_tester.prepare_config_and_inputs_for_common()
           lowerCAmelCase_    :		Any 						=      inputs_dict['pixel_values'].shape[0]

           for backbone_class in self.all_model_classes:
               lowerCAmelCase_    :		Any 						=      backbone_class(UpperCAmelCase	)
               backbone.to(UpperCAmelCase	)
               backbone.eval()

               lowerCAmelCase_    :		Optional[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
               lowerCAmelCase_    :		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:
                   lowerCAmelCase_    :		List[Any] 						=      backbone(**UpperCAmelCase    ,	output_attentions=UpperCAmelCase	)
                   self.assertIsNotNone(outputs.attentions	)






'''simple docstring'''







import sys

sys.set_int_max_str_digits(0)  # type: ignore






def       lowerCAmelCase__       (				lowerCamelCase     :			int   ):
       _A     :	Optional[Any]      =					[0] * 11
       _A     :	str      =					[0] * 11

       # mark last 9 numbers
       for _ in range(9   ):
              _A     :	int      =					1
              _A     :	Optional[int]      =					number // 10
       # flag
       _A     :	List[Any]      =					True

       # check last 9 numbers for pandigitality

       for x in range(9   ):
              if not check_last[x + 1]:
                     _A     :	Optional[int]      =					False
       if not f:
              return f

       # mark first 9 numbers
       _A     :	Optional[int]      =					int(str(lowerCamelCase   )[:9]   )

       for _ in range(9   ):
              _A     :	Optional[Any]      =					1
              _A     :	str      =					number // 10

       # check first 9 numbers for pandigitality

       for x in range(9   ):
              if not check_front[x + 1]:
                     _A     :	Optional[Any]      =					False
       return f






def       lowerCAmelCase__       (				lowerCamelCase     :			int   ):
       _A     :	Dict      =					[0] * 11

       # mark last 9 numbers
       for _ in range(9   ):
              _A     :	List[str]      =					1
              _A     :	Dict      =					number // 10
       # flag
       _A     :	Optional[int]      =					True

       # check last 9 numbers for pandigitality

       for x in range(9   ):
              if not check_last[x + 1]:
                     _A     :	List[str]      =					False
       return f






def       lowerCAmelCase__       (				):
       _A     :	List[Any]      =					1
       _A     :	Dict      =					1
       _A     :	Dict      =					2
       # temporary Fibonacci numbers

       _A     :	List[Any]      =					1
       _A     :	Union[str, Any]      =					1
       _A     :	List[Any]      =					2
       # temporary Fibonacci numbers mod 1e9

       # mod m=1e9, done for fast optimisation
       _A     :	Tuple      =					[0] * 1000000
       _A     :	Any      =					1000000000

       for x in range(1000000   ):
              _A     :	Tuple      =					(aa + ba) % m
              _A     :	Optional[Any]      =					ba % m
              _A     :	str      =					ca % m
              if checka(lowerCamelCase   ):
                     _A     :	Dict      =					1

       for x in range(1000000   ):
              _A     :	List[str]      =					a + b
              _A     :	Optional[int]      =					b
              _A     :	str      =					c
              # perform check only if in tocheck
              if tocheck[x + 3] and check(lowerCamelCase   ):
                     return x + 3  # first 2 already done
       return -1


if __name__ == "__main__":
   print(f"""{solution() = }""")






