code: from __future__ import annotations
  
  import unittest
  
  from transformers import is_tf_available
  from transformers.testing_utils import require_tf, slow
  
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_tf_available():
   import tensorflow as tf
  
   from transformers import (
       TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
       TFXLMForMultipleChoice,
       TFXLMForQuestionAnsweringSimple,
       TFXLMForSequenceClassification,
       TFXLMForTokenClassification,
       TFXLMModel,
       TFXLMWithLMHeadModel,
       XLMConfig,
   )
  
  class 				_lowercase						:
  
  
  
  
  
  
      '''simple docstring'''
  
  
  
  
      def __init__(						self					,	lowerCamelCase__					,	):
         lowerCAmelCase_:       List[str]         =  parent
         lowerCAmelCase_:       List[Any]         =  13
         lowerCAmelCase_:       Any         =  7
         lowerCAmelCase_:       Tuple         =  True
         lowerCAmelCase_:       Any         =  True
         lowerCAmelCase_:       Union[str, Any]         =  True
         lowerCAmelCase_:       Tuple         =  True
         lowerCAmelCase_:       Optional[int]         =  True
         lowerCAmelCase_:       Tuple         =  False
         lowerCAmelCase_:       Union[str, Any]         =  False
         lowerCAmelCase_:       List[Any]         =  False
         lowerCAmelCase_:       Union[str, Any]         =  2
         lowerCAmelCase_:       Any         =  99
         lowerCAmelCase_:       str         =  0
         lowerCAmelCase_:       Optional[Any]         =  32
         lowerCAmelCase_:       Optional[Any]         =  2
         lowerCAmelCase_:       int         =  4
         lowerCAmelCase_:       Union[str, Any]         =  0.1
         lowerCAmelCase_:       List[Any]         =  0.1
         lowerCAmelCase_:       List[Any]         =  512
         lowerCAmelCase_:       Tuple         =  16
         lowerCAmelCase_:       Tuple         =  2
         lowerCAmelCase_:       List[Any]         =  0.0_2
         lowerCAmelCase_:       Optional[int]         =  3
         lowerCAmelCase_:       Optional[int]         =  4
         lowerCAmelCase_:       List[Any]         =  """last"""
         lowerCAmelCase_:       List[str]         =  True
         lowerCAmelCase_:       Any         =  None
         lowerCAmelCase_:       Any         =  0
  
  
  
  
      def     _a						(						self   ):
         lowerCAmelCase_:       int         =  ids_tensor([self.batch_size, self.seq_length]					,	self.vocab_size   )
         lowerCAmelCase_:       Tuple         =  random_attention_mask([self.batch_size, self.seq_length]					,	dtype=tf.floataa   )
  
         lowerCAmelCase_:       Dict         =  None
         if self.use_input_lengths:
            lowerCAmelCase_:       Tuple         =  (
                ids_tensor([self.batch_size]					,	vocab_size=2   ) + self.seq_length - 2
            )  # small variation of seq_length
  
         lowerCAmelCase_:       int         =  None
         if self.use_token_type_ids:
            lowerCAmelCase_:       str         =  ids_tensor([self.batch_size, self.seq_length]					,	self.n_langs   )
  
         lowerCAmelCase_:       Tuple         =  None
         lowerCAmelCase_:       Dict         =  None
         lowerCAmelCase_:       List[Any]         =  None
         if self.use_labels:
            lowerCAmelCase_:       Optional[int]         =  ids_tensor([self.batch_size]					,	self.type_sequence_label_size   )
            lowerCAmelCase_:       int         =  ids_tensor([self.batch_size, self.seq_length]					,	self.num_labels   )
            lowerCAmelCase_:       Dict         =  ids_tensor([self.batch_size]					,	2					,	dtype=tf.floataa   )
            lowerCAmelCase_:       List[str]         =  ids_tensor([self.batch_size]					,	self.num_choices   )
  
         lowerCAmelCase_:       Tuple         =  XLMConfig(
             vocab_size=self.vocab_size					,	n_special=self.n_special					,	emb_dim=self.hidden_size					,	n_layers=self.num_hidden_layers					,	n_heads=self.num_attention_heads					,	dropout=self.hidden_dropout_prob					,	attention_dropout=self.attention_probs_dropout_prob					,	gelu_activation=self.gelu_activation					,	sinusoidal_embeddings=self.sinusoidal_embeddings					,	asm=self.asm					,	causal=self.causal					,	n_langs=self.n_langs					,	max_position_embeddings=self.max_position_embeddings					,	initializer_range=self.initializer_range					,	summary_type=self.summary_type					,	use_proj=self.use_proj					,	bos_token_id=self.bos_token_id					,	)
  
         return (
             config,
             input_ids,
             token_type_ids,
             input_lengths,
             sequence_labels,
             token_labels,
             is_impossible_labels,
             choice_labels,
             input_mask,
         )
  
  
  
  
      def     _a						(						self					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	):
         lowerCAmelCase_:       Union[str, Any]         =  TFXLMModel(config=_lowerCAmelCase   )
         lowerCAmelCase_:       Optional[Any]         =  {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
         lowerCAmelCase_:       List[Any]         =  model(_lowerCAmelCase   )
  
         lowerCAmelCase_:       str         =  [input_ids, input_mask]
         lowerCAmelCase_:       str         =  model(_lowerCAmelCase   )
         self.parent.assertEqual(result.last_hidden_state.shape					,	(self.batch_size, self.seq_length, self.hidden_size)   )
  
  
  
  
      def     _a						(						self					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	):
         lowerCAmelCase_:       Optional[Any]         =  TFXLMWithLMHeadModel(_lowerCAmelCase   )
  
         lowerCAmelCase_:       int         =  {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
         lowerCAmelCase_:       List[str]         =  model(_lowerCAmelCase   )
  
         lowerCAmelCase_:       str         =  outputs
  
         self.parent.assertEqual(result.logits.shape					,	(self.batch_size, self.seq_length, self.vocab_size)   )
  
  
  
  
      def     _a						(						self					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	):
         lowerCAmelCase_:       Tuple         =  TFXLMForQuestionAnsweringSimple(_lowerCAmelCase   )
  
         lowerCAmelCase_:       Dict         =  {"""input_ids""": input_ids, """lengths""": input_lengths}
  
         lowerCAmelCase_:       Union[str, Any]         =  model(_lowerCAmelCase   )
  
         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     _a						(						self					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	):
         lowerCAmelCase_:       List[Any]         =  TFXLMForSequenceClassification(_lowerCAmelCase   )
  
         lowerCAmelCase_:       Tuple         =  {"""input_ids""": input_ids, """lengths""": input_lengths}
  
         lowerCAmelCase_:       Tuple         =  model(_lowerCAmelCase   )
  
         self.parent.assertEqual(result.logits.shape					,	(self.batch_size, self.type_sequence_label_size)   )
  
  
  
  
      def     _a						(						self					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	):
         lowerCAmelCase_:       Union[str, Any]         =  self.num_labels
         lowerCAmelCase_:       Optional[Any]         =  TFXLMForTokenClassification(config=_lowerCAmelCase   )
         lowerCAmelCase_:       str         =  {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
         lowerCAmelCase_:       Union[str, Any]         =  model(_lowerCAmelCase   )
         self.parent.assertEqual(result.logits.shape					,	(self.batch_size, self.seq_length, self.num_labels)   )
  
  
  
  
      def     _a						(						self					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	):
         lowerCAmelCase_:       List[Any]         =  self.num_choices
         lowerCAmelCase_:       Optional[int]         =  TFXLMForMultipleChoice(config=_lowerCAmelCase   )
         lowerCAmelCase_:       Tuple         =  tf.tile(tf.expand_dims(_lowerCAmelCase					,	1   )					,	(1, self.num_choices, 1)   )
         lowerCAmelCase_:       List[Any]         =  tf.tile(tf.expand_dims(_lowerCAmelCase					,	1   )					,	(1, self.num_choices, 1)   )
         lowerCAmelCase_:       Optional[Any]         =  tf.tile(tf.expand_dims(_lowerCAmelCase					,	1   )					,	(1, self.num_choices, 1)   )
         lowerCAmelCase_:       Union[str, Any]         =  {
             """input_ids""": multiple_choice_inputs_ids,
             """attention_mask""": multiple_choice_input_mask,
             """token_type_ids""": multiple_choice_token_type_ids,
         }
         lowerCAmelCase_:       Optional[Any]         =  model(_lowerCAmelCase   )
         self.parent.assertEqual(result.logits.shape					,	(self.batch_size, self.num_choices)   )
  
  
  
  
      def     _a						(						self   ):
         lowerCAmelCase_:       int         =  self.prepare_config_and_inputs()
         (
             lowerCAmelCase_		
         ):       Dict         =  config_and_inputs
         lowerCAmelCase_:       str         =  {
             """input_ids""": input_ids,
             """token_type_ids""": token_type_ids,
             """langs""": token_type_ids,
             """lengths""": input_lengths,
         }
         return config, inputs_dict
  
  
  
  
  
  @require_tf
  class 				_lowercase						(    __lowerCamelCase   ,     __lowerCamelCase   ,     unittest.TestCase ):
  
  
  
  
  
  
      '''simple docstring'''
      SCREAMING_SNAKE_CASE:							List[Any]        =						(
          (
              TFXLMModel,
              TFXLMWithLMHeadModel,
              TFXLMForSequenceClassification,
              TFXLMForQuestionAnsweringSimple,
              TFXLMForTokenClassification,
              TFXLMForMultipleChoice,
          )
          if is_tf_available()
          else ()
      )
      SCREAMING_SNAKE_CASE:							Optional[int]        =						(
          (TFXLMWithLMHeadModel,) if is_tf_available() else ()
      )  # TODO (PVP): Check other models whether language generation is also applicable
      SCREAMING_SNAKE_CASE:							List[Any]        =						(
          {
              'feature-extraction': TFXLMModel,
              'fill-mask': TFXLMWithLMHeadModel,
              'question-answering': TFXLMForQuestionAnsweringSimple,
              'text-classification': TFXLMForSequenceClassification,
              'text-generation': TFXLMWithLMHeadModel,
              'token-classification': TFXLMForTokenClassification,
              'zero-shot': TFXLMForSequenceClassification,
          }
          if is_tf_available()
          else {}
      )
      SCREAMING_SNAKE_CASE:							List[Any]        =						False
      SCREAMING_SNAKE_CASE:							int        =						False
  
  
  
  
      def     _a						(						self					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__					,	lowerCamelCase__   ):
         if (
             pipeline_test_casse_name == "QAPipelineTests"
             and tokenizer_name is not None
             and not tokenizer_name.endswith("Fast"   )
         ):
            # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
            # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
            # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
            return True
  
         return False
  
  
  
  
      def     _a						(						self   ):
         lowerCAmelCase_:       List[Any]         =  TFXLMModelTester(self   )
         lowerCAmelCase_:       Optional[Any]         =  ConfigTester(self					,	config_class=_lowerCAmelCase					,	emb_dim=37   )
  
  
  
  
      def     _a						(						self   ):
         self.config_tester.run_common_tests()
  
  
  
  
      def     _a						(						self   ):
         lowerCAmelCase_:       Tuple         =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_model(*_lowerCAmelCase   )
  
  
  
  
      def     _a						(						self   ):
         lowerCAmelCase_:       str         =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_lm_head(*_lowerCAmelCase   )
  
  
  
  
      def     _a						(						self   ):
         lowerCAmelCase_:       Optional[Any]         =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_qa(*_lowerCAmelCase   )
  
  
  
  
      def     _a						(						self   ):
         lowerCAmelCase_:       Tuple         =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_sequence_classif(*_lowerCAmelCase   )
  
  
  
  
      def     _a						(						self   ):
         lowerCAmelCase_:       int         =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_for_token_classification(*_lowerCAmelCase   )
  
  
  
  
      def     _a						(						self   ):
         lowerCAmelCase_:       Dict         =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_for_multiple_choice(*_lowerCAmelCase   )
  
  
  
  
      @slow
      def     _a						(						self   ):
         for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            lowerCAmelCase_:       int         =  TFXLMModel.from_pretrained(_lowerCAmelCase   )
            self.assertIsNotNone(_lowerCAmelCase   )
  
  
  
  
  
  @require_tf
  class 				_lowercase						(    unittest.TestCase ):
  
  
  
  
  
  
      '''simple docstring'''
  
  
  
  
      @slow
      def     _a						(						self   ):
         lowerCAmelCase_:       Optional[int]         =  TFXLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048"   )
         lowerCAmelCase_:       Dict         =  tf.convert_to_tensor([[14, 447]]					,	dtype=tf.intaa   )  # the president
         lowerCAmelCase_:       str         =  [
             14,
             447,
             14,
             447,
             14,
             447,
             14,
             447,
             14,
             447,
             14,
             447,
             14,
             447,
             14,
             447,
             14,
             447,
             14,
             447,
         ]  # the president the president the president the president the president the president the president the president the president the president
         # TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
         lowerCAmelCase_:       List[str]         =  model.generate(_lowerCAmelCase					,	do_sample=_lowerCAmelCase   )
         self.assertListEqual(output_ids[0].numpy().tolist()					,	_lowerCAmelCase   )
  
  
  
  
style_context: import itertools
  def 		snake_case__  (		lowercase				):
     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 		snake_case__  (		):
     return sum(
         {
             int("".join(pandigital[5:9]				)				)
             for pandigital in itertools.permutations("123456789"				)
             if is_combination_valid(lowercase				)
         }				)
  
  
  if __name__ == "__main__":
   print(solution())