
"""simple docstring"""







import unittest

from transformers import LayoutLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import (
      LayoutLMForMaskedLM,
      LayoutLMForQuestionAnswering,
      LayoutLMForSequenceClassification,
      LayoutLMForTokenClassification,
      LayoutLMModel,
  )






class      __a      :







       def __init__(       self				,lowerCamelCase_				,lowerCamelCase_=13				,lowerCamelCase_=7				,lowerCamelCase_=True				,lowerCamelCase_=True				,lowerCamelCase_=True				,lowerCamelCase_=True				,lowerCamelCase_=99				,lowerCamelCase_=32				,lowerCamelCase_=5				,lowerCamelCase_=4				,lowerCamelCase_=37				,lowerCamelCase_="gelu"				,lowerCamelCase_=0.1				,lowerCamelCase_=0.1				,lowerCamelCase_=512				,lowerCamelCase_=16				,lowerCamelCase_=2				,lowerCamelCase_=0.0_2				,lowerCamelCase_=3				,lowerCamelCase_=4				,lowerCamelCase_=None				,lowerCamelCase_=1000				,):



          '''simple docstring'''

          _UpperCAmelCase 						=       parent
          _UpperCAmelCase 						=       batch_size
          _UpperCAmelCase 						=       seq_length
          _UpperCAmelCase 						=       is_training
          _UpperCAmelCase 						=       use_input_mask
          _UpperCAmelCase 						=       use_token_type_ids
          _UpperCAmelCase 						=       use_labels
          _UpperCAmelCase 						=       vocab_size
          _UpperCAmelCase 						=       hidden_size
          _UpperCAmelCase 						=       num_hidden_layers
          _UpperCAmelCase 						=       num_attention_heads
          _UpperCAmelCase 						=       intermediate_size
          _UpperCAmelCase 						=       hidden_act
          _UpperCAmelCase 						=       hidden_dropout_prob
          _UpperCAmelCase 						=       attention_probs_dropout_prob
          _UpperCAmelCase 						=       max_position_embeddings
          _UpperCAmelCase 						=       type_vocab_size
          _UpperCAmelCase 						=       type_sequence_label_size
          _UpperCAmelCase 						=       initializer_range
          _UpperCAmelCase 						=       num_labels
          _UpperCAmelCase 						=       num_choices
          _UpperCAmelCase 						=       scope
          _UpperCAmelCase 						=       range_bbox







       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       ids_tensor([self.batch_size, self.seq_length]				,self.vocab_size		)

          _UpperCAmelCase 						=       ids_tensor([self.batch_size, self.seq_length, 4]				,self.range_bbox		)
          # Ensure that bbox is legal
          for i in range(bbox.shape[0]		):
             for j in range(bbox.shape[1]		):
                if bbox[i, j, 3] < bbox[i, j, 1]:
                   _UpperCAmelCase 						=       bbox[i, j, 3]
                   _UpperCAmelCase 						=       bbox[i, j, 1]
                   _UpperCAmelCase 						=       t
                if bbox[i, j, 2] < bbox[i, j, 0]:
                   _UpperCAmelCase 						=       bbox[i, j, 2]
                   _UpperCAmelCase 						=       bbox[i, j, 0]
                   _UpperCAmelCase 						=       t

          _UpperCAmelCase 						=       None
          if self.use_input_mask:
             _UpperCAmelCase 						=       ids_tensor([self.batch_size, self.seq_length]				,vocab_size=2		)

          _UpperCAmelCase 						=       None
          if self.use_token_type_ids:
             _UpperCAmelCase 						=       ids_tensor([self.batch_size, self.seq_length]				,self.type_vocab_size		)

          _UpperCAmelCase 						=       None
          _UpperCAmelCase 						=       None
          _UpperCAmelCase 						=       None
          if self.use_labels:
             _UpperCAmelCase 						=       ids_tensor([self.batch_size]				,self.type_sequence_label_size		)
             _UpperCAmelCase 						=       ids_tensor([self.batch_size, self.seq_length]				,self.num_labels		)
             _UpperCAmelCase 						=       ids_tensor([self.batch_size]				,self.num_choices		)

          _UpperCAmelCase 						=       self.get_config()

          return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels







       def  _snake_case      (       self		):



          '''simple docstring'''

          return LayoutLMConfig(
              vocab_size=self.vocab_size				,hidden_size=self.hidden_size				,num_hidden_layers=self.num_hidden_layers				,num_attention_heads=self.num_attention_heads				,intermediate_size=self.intermediate_size				,hidden_act=self.hidden_act				,hidden_dropout_prob=self.hidden_dropout_prob				,attention_probs_dropout_prob=self.attention_probs_dropout_prob				,max_position_embeddings=self.max_position_embeddings				,type_vocab_size=self.type_vocab_size				,initializer_range=self.initializer_range				,)







       def  _snake_case      (       self				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_		):



          '''simple docstring'''

          _UpperCAmelCase 						=       LayoutLMModel(config=SCREAMING_SNAKE_CASE__		)
          model.to(SCREAMING_SNAKE_CASE__		)
          model.eval()
          _UpperCAmelCase 						=       model(SCREAMING_SNAKE_CASE__				,SCREAMING_SNAKE_CASE__				,attention_mask=SCREAMING_SNAKE_CASE__				,token_type_ids=SCREAMING_SNAKE_CASE__		)
          _UpperCAmelCase 						=       model(SCREAMING_SNAKE_CASE__				,SCREAMING_SNAKE_CASE__				,token_type_ids=SCREAMING_SNAKE_CASE__		)
          _UpperCAmelCase 						=       model(SCREAMING_SNAKE_CASE__				,SCREAMING_SNAKE_CASE__		)
          self.parent.assertEqual(result.last_hidden_state.shape				,(self.batch_size, self.seq_length, self.hidden_size)		)
          self.parent.assertEqual(result.pooler_output.shape				,(self.batch_size, self.hidden_size)		)







       def  _snake_case      (       self				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_		):



          '''simple docstring'''

          _UpperCAmelCase 						=       LayoutLMForMaskedLM(config=SCREAMING_SNAKE_CASE__		)
          model.to(SCREAMING_SNAKE_CASE__		)
          model.eval()
          _UpperCAmelCase 						=       model(SCREAMING_SNAKE_CASE__				,SCREAMING_SNAKE_CASE__				,attention_mask=SCREAMING_SNAKE_CASE__				,token_type_ids=SCREAMING_SNAKE_CASE__				,labels=SCREAMING_SNAKE_CASE__		)
          self.parent.assertEqual(result.logits.shape				,(self.batch_size, self.seq_length, self.vocab_size)		)







       def  _snake_case      (       self				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_		):



          '''simple docstring'''

          _UpperCAmelCase 						=       self.num_labels
          _UpperCAmelCase 						=       LayoutLMForSequenceClassification(SCREAMING_SNAKE_CASE__		)
          model.to(SCREAMING_SNAKE_CASE__		)
          model.eval()
          _UpperCAmelCase 						=       model(
              SCREAMING_SNAKE_CASE__				,SCREAMING_SNAKE_CASE__				,attention_mask=SCREAMING_SNAKE_CASE__				,token_type_ids=SCREAMING_SNAKE_CASE__				,labels=SCREAMING_SNAKE_CASE__		)
          self.parent.assertEqual(result.logits.shape				,(self.batch_size, self.num_labels)		)







       def  _snake_case      (       self				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_		):



          '''simple docstring'''

          _UpperCAmelCase 						=       self.num_labels
          _UpperCAmelCase 						=       LayoutLMForTokenClassification(config=SCREAMING_SNAKE_CASE__		)
          model.to(SCREAMING_SNAKE_CASE__		)
          model.eval()
          _UpperCAmelCase 						=       model(SCREAMING_SNAKE_CASE__				,SCREAMING_SNAKE_CASE__				,attention_mask=SCREAMING_SNAKE_CASE__				,token_type_ids=SCREAMING_SNAKE_CASE__				,labels=SCREAMING_SNAKE_CASE__		)
          self.parent.assertEqual(result.logits.shape				,(self.batch_size, self.seq_length, self.num_labels)		)







       def  _snake_case      (       self				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_		):



          '''simple docstring'''

          _UpperCAmelCase 						=       LayoutLMForQuestionAnswering(config=SCREAMING_SNAKE_CASE__		)
          model.to(SCREAMING_SNAKE_CASE__		)
          model.eval()
          _UpperCAmelCase 						=       model(
              SCREAMING_SNAKE_CASE__				,bbox=SCREAMING_SNAKE_CASE__				,attention_mask=SCREAMING_SNAKE_CASE__				,token_type_ids=SCREAMING_SNAKE_CASE__				,start_positions=SCREAMING_SNAKE_CASE__				,end_positions=SCREAMING_SNAKE_CASE__				,)
          self.parent.assertEqual(result.start_logits.shape				,(self.batch_size, self.seq_length)		)
          self.parent.assertEqual(result.end_logits.shape				,(self.batch_size, self.seq_length)		)







       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       self.prepare_config_and_inputs()
          (
              (
              _UpperCAmelCase							
          )						,				(
              _UpperCAmelCase							
          )						,				(
              _UpperCAmelCase							
          )						,				(
              _UpperCAmelCase							
          )						,				(
              _UpperCAmelCase							
          )						,				(
              _UpperCAmelCase							
          )						,				(
              _UpperCAmelCase							
          )						,				(
              _UpperCAmelCase							
          )						,											
          ) 						=       config_and_inputs
          _UpperCAmelCase 						=       {
              "input_ids": input_ids,
              "bbox": bbox,
              "token_type_ids": token_type_ids,
              "attention_mask": input_mask,
          }
          return config, inputs_dict






@require_torch
class      __a      (       __a					,						__a					,						unittest.TestCase      ):
       _lowerCamelCase				:				Tuple   			=      (
           (
               LayoutLMModel,
               LayoutLMForMaskedLM,
               LayoutLMForSequenceClassification,
               LayoutLMForTokenClassification,
               LayoutLMForQuestionAnswering,
           )
           if is_torch_available()
           else None
       )
       _lowerCamelCase				:				int   			=      (
           {
               'document-question-answering': LayoutLMForQuestionAnswering,
               'feature-extraction': LayoutLMModel,
               'fill-mask': LayoutLMForMaskedLM,
               'text-classification': LayoutLMForSequenceClassification,
               'token-classification': LayoutLMForTokenClassification,
               'zero-shot': LayoutLMForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )
       _lowerCamelCase				:				List[Any]   			=      True







       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       LayoutLMModelTester(self		)
          _UpperCAmelCase 						=       ConfigTester(self				,config_class=SCREAMING_SNAKE_CASE__				,hidden_size=37		)







       def  _snake_case      (       self		):



          '''simple docstring'''

          self.config_tester.run_common_tests()







       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__		)







       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       self.model_tester.prepare_config_and_inputs()
          for type in ["absolute", "relative_key", "relative_key_query"]:
             _UpperCAmelCase 						=       type
             self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__		)







       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_lm(*SCREAMING_SNAKE_CASE__		)







       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE__		)







       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE__		)







       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE__		)







       @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."		)
       def  _snake_case      (       self		):



          '''simple docstring'''

          pass



def       __UpperCAmelCase		(		)  ->							Union[str, Any]:
   _UpperCAmelCase 						=       torch.tensor([[1_01,10_19,10_14,10_16,10_37,1_28_49,47_47,10_04,1_42_46,22_78,54_39,45_24,50_02,29_30,21_93,29_30,43_41,32_08,10_05,10_55,21_71,28_48,1_13_00,35_31,1_02],[1_01,40_70,40_34,70_20,10_24,30_58,10_15,10_13,28_61,10_13,60_70,1_92_74,27_72,62_05,2_78_14,1_61_47,1_61_47,43_43,20_47,1_02_83,1_09_69,1_43_89,10_12,23_38,1_02]]     ,	device=A__					)  # noqa: E231
   _UpperCAmelCase 						=       torch.tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],]     ,	device=A__					)  # noqa: E231
   _UpperCAmelCase 						=       torch.tensor([[[0,0,0,0],[4_23,2_37,4_40,2_51],[4_27,2_72,4_41,2_87],[4_19,1_15,4_37,1_29],[9_61,8_85,9_92,9_12],[2_56,38,3_30,58],[2_56,38,3_30,58],[3_36,42,3_53,57],[3_60,39,4_01,56],[3_60,39,4_01,56],[4_11,39,4_71,59],[4_79,41,5_28,59],[5_33,39,6_30,60],[67,1_13,1_34,1_31],[1_41,1_15,2_09,1_32],[68,1_49,1_33,1_66],[1_41,1_49,1_87,1_64],[1_95,1_48,2_87,1_65],[1_95,1_48,2_87,1_65],[1_95,1_48,2_87,1_65],[2_95,1_48,3_49,1_65],[4_41,1_49,4_92,1_66],[4_97,1_49,5_46,1_64],[64,2_01,1_25,2_18],[10_00,10_00,10_00,10_00]],[[0,0,0,0],[6_62,1_50,7_54,1_66],[6_65,1_99,7_42,2_11],[5_19,2_13,5_54,2_28],[5_19,2_13,5_54,2_28],[1_34,4_33,1_87,4_54],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[3_14,4_69,3_76,4_82],[5_04,6_84,5_82,7_06],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[6_10,7_49,6_52,7_65],[1_30,6_59,1_68,6_72],[1_76,6_57,2_37,6_72],[2_38,6_57,3_12,6_72],[4_43,6_53,6_28,6_72],[4_43,6_53,6_28,6_72],[7_16,3_01,8_25,3_17],[10_00,10_00,10_00,10_00]]]     ,	device=A__					)  # noqa: E231
   _UpperCAmelCase 						=       torch.tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]     ,	device=A__					)  # noqa: E231
   # these are sequence labels (i.e. at the token level)
   _UpperCAmelCase 						=       torch.tensor([[-1_00,10,10,10,9,1,-1_00,7,7,-1_00,7,7,4,2,5,2,8,8,-1_00,-1_00,5,0,3,2,-1_00],[-1_00,12,12,12,-1_00,12,10,-1_00,-1_00,-1_00,-1_00,10,12,9,-1_00,-1_00,-1_00,10,10,10,9,12,-1_00,10,-1_00]]     ,	device=A__					)  # noqa: E231
   # fmt: on

   return input_ids, attention_mask, bbox, token_type_ids, labels






@require_torch
class      __a      (       unittest.TestCase      ):







       @slow
       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       LayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased"		).to(SCREAMING_SNAKE_CASE__		)

          _UpperCAmelCase						,				_UpperCAmelCase						,				_UpperCAmelCase						,				_UpperCAmelCase						,				_UpperCAmelCase 						=       prepare_layoutlm_batch_inputs()

          # forward pass
          _UpperCAmelCase 						=       model(input_ids=SCREAMING_SNAKE_CASE__				,bbox=SCREAMING_SNAKE_CASE__				,attention_mask=SCREAMING_SNAKE_CASE__				,token_type_ids=SCREAMING_SNAKE_CASE__		)

          # test the sequence output on [0, :3, :3]
          _UpperCAmelCase 						=       torch.tensor(
              [[0.1_7_8_5, -0.1_9_4_7, -0.0_4_2_5], [-0.3_2_5_4, -0.2_8_0_7, 0.2_5_5_3], [-0.5_3_9_1, -0.3_3_2_2, 0.3_3_6_4]]				,device=SCREAMING_SNAKE_CASE__				,)

          self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]				,SCREAMING_SNAKE_CASE__				,atol=1e-3		)		)

          # test the pooled output on [1, :3]
          _UpperCAmelCase 						=       torch.tensor([-0.6_5_8_0, -0.0_2_1_4, 0.8_5_5_2]				,device=SCREAMING_SNAKE_CASE__		)

          self.assertTrue(torch.allclose(outputs.pooler_output[1, :3]				,SCREAMING_SNAKE_CASE__				,atol=1e-3		)		)







       @slow
       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       LayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased"				,num_labels=2		).to(
              SCREAMING_SNAKE_CASE__		)

          _UpperCAmelCase						,				_UpperCAmelCase						,				_UpperCAmelCase						,				_UpperCAmelCase						,				_UpperCAmelCase 						=       prepare_layoutlm_batch_inputs()

          # forward pass
          _UpperCAmelCase 						=       model(
              input_ids=SCREAMING_SNAKE_CASE__				,bbox=SCREAMING_SNAKE_CASE__				,attention_mask=SCREAMING_SNAKE_CASE__				,token_type_ids=SCREAMING_SNAKE_CASE__				,labels=torch.tensor([1, 1]				,device=SCREAMING_SNAKE_CASE__		)				,)

          # test whether we get a loss as a scalar
          _UpperCAmelCase 						=       outputs.loss
          _UpperCAmelCase 						=       torch.Size([]		)
          self.assertEqual(loss.shape				,SCREAMING_SNAKE_CASE__		)

          # test the shape of the logits
          _UpperCAmelCase 						=       outputs.logits
          _UpperCAmelCase 						=       torch.Size((2, 2)		)
          self.assertEqual(logits.shape				,SCREAMING_SNAKE_CASE__		)







       @slow
       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       LayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased"				,num_labels=13		).to(
              SCREAMING_SNAKE_CASE__		)

          _UpperCAmelCase						,				_UpperCAmelCase						,				_UpperCAmelCase						,				_UpperCAmelCase						,				_UpperCAmelCase 						=       prepare_layoutlm_batch_inputs()

          # forward pass
          _UpperCAmelCase 						=       model(
              input_ids=SCREAMING_SNAKE_CASE__				,bbox=SCREAMING_SNAKE_CASE__				,attention_mask=SCREAMING_SNAKE_CASE__				,token_type_ids=SCREAMING_SNAKE_CASE__				,labels=SCREAMING_SNAKE_CASE__		)

          # test the loss calculation to be around 2.65
          # expected_loss = torch.tensor(2.65, device=torch_device)

          # The loss is currently somewhat random and can vary between 0.1-0.3 atol.
          # self.assertTrue(torch.allclose(outputs.loss, expected_loss, atol=0.1))

          # test the shape of the logits
          _UpperCAmelCase 						=       outputs.logits
          _UpperCAmelCase 						=       torch.Size((2, 25, 13)		)
          self.assertEqual(logits.shape				,SCREAMING_SNAKE_CASE__		)







       @slow
       def  _snake_case      (       self		):



          '''simple docstring'''

          _UpperCAmelCase 						=       LayoutLMForQuestionAnswering.from_pretrained("microsoft/layoutlm-base-uncased"		).to(SCREAMING_SNAKE_CASE__		)

          _UpperCAmelCase						,				_UpperCAmelCase						,				_UpperCAmelCase						,				_UpperCAmelCase						,				_UpperCAmelCase 						=       prepare_layoutlm_batch_inputs()

          # forward pass
          _UpperCAmelCase 						=       model(input_ids=SCREAMING_SNAKE_CASE__				,bbox=SCREAMING_SNAKE_CASE__				,attention_mask=SCREAMING_SNAKE_CASE__				,token_type_ids=SCREAMING_SNAKE_CASE__		)

          # test the shape of the logits
          _UpperCAmelCase 						=       torch.Size((2, 25)		)
          self.assertEqual(outputs.start_logits.shape				,SCREAMING_SNAKE_CASE__		)
          self.assertEqual(outputs.end_logits.shape				,SCREAMING_SNAKE_CASE__		)




"""simple docstring"""




from __future__ import annotations

import math
from itertools import permutations



def 						UpperCAmelCase__ (					A__ )   ->   bool:




   """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 						UpperCAmelCase__ (					A__ = 7 )   ->   int:




   """simple docstring"""
   lowerCamelCase__						       =      "".join(str(A__ ) for i in range(1						,     n + 1 ) )
   lowerCamelCase__						       =      [int("".join(A__ ) ) for i in permutations(A__						,     A__ )]
   lowerCamelCase__						       =      [num for num in perm_list if is_prime(A__ )]
   return max(A__ ) if pandigitals else 0


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




