



from __future__ import annotations

import math
from itertools import permutations







def       lowerCamelCase_  (    _a       :						int    ):



    '''simple docstring'''




    if 1 < number < 4:
        # 2 and 3 are primes
        return True
    elif number < 2 or number % 2 == 0 or number % 3 == 0:
        # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
        return False

    # All primes number are in format of 6k +/- 1
    for i in range(5   ,		int(math.sqrt(_a    ) + 1    )   ,		6    ):
        if number % i == 0 or number % (i + 2) == 0:
            return False
    return True







def       lowerCamelCase_  (    _a       :						int = 7    ):



    '''simple docstring'''




    UpperCAmelCase_     :       Any  		=					"""""".join(str(_a    ) for i in range(1   ,		n + 1    )    )
    UpperCAmelCase_     :       List[str]  		=					[int("""""".join(_a    )    ) for i in permutations(_a   ,		_a    )]
    UpperCAmelCase_     :       Optional[int]  		=					[num for num in perm_list if is_prime(_a    )]
    return max(_a    ) if pandigitals else 0


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







"""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       :
       lowerCAmelCase__    			=	()
       lowerCAmelCase__    			=	True






       def 				__A			( self  ):
              _UpperCAmelCase			     =  self.config_class

              # test default config
              _UpperCAmelCase			     =  config_class()
              self.assertIsNotNone(a__  )
              _UpperCAmelCase			     =  ['stem'] + [f"""stage{idx}""" for idx in range(1     ,	len(config.depths  ) + 1  )]
              self.assertEqual(config.stage_names     ,	a__  )
              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=a__     ,	out_indices=a__  )
              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(a__  ):
                     _UpperCAmelCase			     =  config_class(out_features=['stage1', 'stage2']     ,	out_indices=[0, 2]  )






       def 				__A			( self  ):
              _UpperCAmelCase     ,				_UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs_for_common()

              for model_class in self.all_model_classes:
                     _UpperCAmelCase			     =  model_class(a__  )
                     _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]     ,	a__  )






       def 				__A			( self  ):
              _UpperCAmelCase     ,				_UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs_for_common()

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

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

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






       def 				__A			( self  ):
              _UpperCAmelCase     ,				_UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs_for_common()

              for model_class in self.all_model_classes:
                     _UpperCAmelCase			     =  model_class(a__  )
                     model.to(a__  )
                     model.eval()
                     _UpperCAmelCase			     =  model(**a__  )

                     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(a__  )
                     _UpperCAmelCase			     =  None
                     _UpperCAmelCase			     =  model_class(a__  )
                     model.to(a__  )
                     model.eval()
                     _UpperCAmelCase			     =  model(**a__  )

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

                     _UpperCAmelCase			     =  copy.deepcopy(a__  )
                     _UpperCAmelCase			     =  None
                     _UpperCAmelCase			     =  model_class(a__  )
                     model.to(a__  )
                     model.eval()
                     _UpperCAmelCase			     =  model(**a__  )

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

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






       def 				__A			( self  ):
              _UpperCAmelCase     ,				_UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs_for_common()

              for backbone_class in self.all_model_classes:
                     _UpperCAmelCase			     =  backbone_class(a__  )

                     self.assertTrue(hasattr(a__     ,	'backbone_type'  )  )
                     self.assertTrue(hasattr(a__     ,	'stage_names'  )  )
                     self.assertTrue(hasattr(a__     ,	'num_features'  )  )
                     self.assertTrue(hasattr(a__     ,	'out_indices'  )  )
                     self.assertTrue(hasattr(a__     ,	'out_features'  )  )
                     self.assertTrue(hasattr(a__     ,	'out_feature_channels'  )  )
                     self.assertTrue(hasattr(a__     ,	'channels'  )  )

                     self.assertIsInstance(backbone.backbone_type     ,	a__  )
                     # 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  ):
              _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(a__  )
                     backbone.to(a__  )
                     backbone.eval()

                     _UpperCAmelCase			     =  backbone(**a__  )

                     # Test default outputs and verify feature maps
                     self.assertIsInstance(outputs.feature_maps     ,	a__  )
                     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(**a__     ,	output_hidden_states=a__  )
                     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(**a__     ,	output_attentions=a__  )
                            self.assertIsNotNone(outputs.attentions  )






