






"""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_       :
  _A				:    Union[str, Any] =		()
  _A				:    Optional[Any] =		True



  def 						UpperCamelCase_ (					self )	->	Any:



         """simple docstring"""





         UpperCAmelCase					=	self.config_class

         # test default config
         UpperCAmelCase					=	config_class()
         self.assertIsNotNone(__UpperCAmelCase )
         UpperCAmelCase					=	["""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
         UpperCAmelCase					=	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
         UpperCAmelCase					=	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
         UpperCAmelCase					=	config_class(out_features=["""stage1""", """stage3"""] )
         self.assertEqual(config.out_features       ,						["""stage1""", """stage3"""] )
         self.assertEqual(config.out_indices       ,						[1, 3] )

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



  def 						UpperCamelCase_ (					self )	->	Tuple:



         """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.forward )
                # 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 						UpperCamelCase_ (					self )	->	Optional[int]:



         """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 )
                self.assertEqual(len(model.channels )       ,						len(config.out_features ) )
                UpperCAmelCase					=	model.num_features
                UpperCAmelCase					=	[config.stage_names.index(__UpperCAmelCase ) for feat in config.out_features]
                UpperCAmelCase					=	[num_features[idx] for idx in out_indices]
                self.assertListEqual(model.channels       ,						__UpperCAmelCase )

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

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



  def 						UpperCamelCase_ (					self )	->	Dict:



         """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 )
                model.to(__UpperCAmelCase )
                model.eval()
                UpperCAmelCase					=	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
                UpperCAmelCase					=	copy.deepcopy(__UpperCAmelCase )
                UpperCAmelCase					=	None
                UpperCAmelCase					=	model_class(__UpperCAmelCase )
                model.to(__UpperCAmelCase )
                model.eval()
                UpperCAmelCase					=	model(**__UpperCAmelCase )

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

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

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

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



  def 						UpperCamelCase_ (					self )	->	List[str]:



         """simple docstring"""





         UpperCAmelCase			,				UpperCAmelCase					=	self.model_tester.prepare_config_and_inputs_for_common()

         for backbone_class in self.all_model_classes:
                UpperCAmelCase					=	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 						UpperCamelCase_ (					self )	->	Union[str, Any]:



         """simple docstring"""





         UpperCAmelCase			,				UpperCAmelCase					=	self.model_tester.prepare_config_and_inputs_for_common()
         UpperCAmelCase					=	inputs_dict["""pixel_values"""].shape[0]

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

                UpperCAmelCase					=	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
                UpperCAmelCase					=	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:
                       UpperCAmelCase					=	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())



