
"""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 		lowerCamelCase__					:





			'''simple docstring'''
			lowerCamelCase  					=		()
			lowerCamelCase  					=		True



			def 					_lowerCAmelCase		(							self  ) ->     Any:
				_lowerCAmelCase								=self.config_class

				# test default config
				_lowerCAmelCase								=config_class()
				self.assertIsNotNone(__UpperCAmelCase  )
				_lowerCAmelCase								=["""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								=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								=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								=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								=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								=config_class(out_features=["""stage1""", """stage2"""]     ,     out_indices=[0, 2]  )



			def 					_lowerCAmelCase		(							self  ) ->     Tuple:
				_lowerCAmelCase						,							_lowerCAmelCase								=self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
					_lowerCAmelCase								=model_class(__UpperCAmelCase  )
					_lowerCAmelCase								=inspect.signature(model.forward  )
					# signature.parameters is an OrderedDict => so arg_names order is deterministic
					_lowerCAmelCase								=[*signature.parameters.keys()]
					_lowerCAmelCase								=["""pixel_values"""]
					self.assertListEqual(arg_names[:1]     ,     __UpperCAmelCase  )



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

				for model_class in self.all_model_classes:
					_lowerCAmelCase								=model_class(__UpperCAmelCase  )
					self.assertEqual(len(model.channels  )     ,     len(config.out_features  )  )
					_lowerCAmelCase								=model.num_features
					_lowerCAmelCase								=[config.stage_names.index(__UpperCAmelCase  ) for feat in config.out_features]
					_lowerCAmelCase								=[num_features[idx] for idx in out_indices]
					self.assertListEqual(model.channels     ,     __UpperCAmelCase  )

					_lowerCAmelCase								=copy.deepcopy(__UpperCAmelCase  )
					_lowerCAmelCase								=None
					_lowerCAmelCase								=model_class(__UpperCAmelCase  )
					self.assertEqual(len(model.channels  )     ,     1  )
					self.assertListEqual(model.channels     ,     [num_features[-1]]  )

					_lowerCAmelCase								=copy.deepcopy(__UpperCAmelCase  )
					_lowerCAmelCase								=None
					_lowerCAmelCase								=model_class(__UpperCAmelCase  )
					self.assertEqual(len(model.channels  )     ,     1  )
					self.assertListEqual(model.channels     ,     [num_features[-1]]  )



			def 					_lowerCAmelCase		(							self  ) ->     Dict:
				_lowerCAmelCase						,							_lowerCAmelCase								=self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
					_lowerCAmelCase								=model_class(__UpperCAmelCase  )
					model.to(__UpperCAmelCase  )
					model.eval()
					_lowerCAmelCase								=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								=copy.deepcopy(__UpperCAmelCase  )
					_lowerCAmelCase								=None
					_lowerCAmelCase								=model_class(__UpperCAmelCase  )
					model.to(__UpperCAmelCase  )
					model.eval()
					_lowerCAmelCase								=model(**__UpperCAmelCase  )

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

					_lowerCAmelCase								=copy.deepcopy(__UpperCAmelCase  )
					_lowerCAmelCase								=None
					_lowerCAmelCase								=model_class(__UpperCAmelCase  )
					model.to(__UpperCAmelCase  )
					model.eval()
					_lowerCAmelCase								=model(**__UpperCAmelCase  )

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

					# Check backbone can be initialized with fresh weights
					_lowerCAmelCase								=copy.deepcopy(__UpperCAmelCase  )
					_lowerCAmelCase								=False
					_lowerCAmelCase								=model_class(__UpperCAmelCase  )
					model.to(__UpperCAmelCase  )
					model.eval()
					_lowerCAmelCase								=model(**__UpperCAmelCase  )



			def 					_lowerCAmelCase		(							self  ) ->     List[str]:
				_lowerCAmelCase						,							_lowerCAmelCase								=self.model_tester.prepare_config_and_inputs_for_common()

				for backbone_class in self.all_model_classes:
					_lowerCAmelCase								=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 					_lowerCAmelCase		(							self  ) ->     Union[str, Any]:
				_lowerCAmelCase						,							_lowerCAmelCase								=self.model_tester.prepare_config_and_inputs_for_common()
				_lowerCAmelCase								=inputs_dict["""pixel_values"""].shape[0]

				for backbone_class in self.all_model_classes:
					_lowerCAmelCase								=backbone_class(__UpperCAmelCase  )
					backbone.to(__UpperCAmelCase  )
					backbone.eval()

					_lowerCAmelCase								=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								=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								=backbone(**__UpperCAmelCase     ,     output_attentions=__UpperCAmelCase  )
						self.assertIsNotNone(outputs.attentions  )





"""simple docstring"""


import itertools



def     _lowerCamelCase(__UpperCamelCase       )				-> List[str]:
	return (
	    int("""""".join(combination[0:2]       )       ) * int("""""".join(combination[2:5]       )       )
	    == int("""""".join(combination[5:9]       )       )
	) or (
	    int("""""".join(combination[0]       )       ) * int("""""".join(combination[1:5]       )       )
	    == int("""""".join(combination[5:9]       )       )
	)



def     _lowerCamelCase()				-> Dict:
	return sum(
	    {
	        int("""""".join(pandigital[5:9]       )       )
	        for pandigital in itertools.permutations("""123456789"""       )
	        if is_combination_valid(__UpperCamelCase       )
	    }       )


if __name__ == "__main__":
			print(solution())



