


'''simple docstring'''






import unittest

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

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import (
		    XLMForMultipleChoice,
		    XLMForQuestionAnswering,
		    XLMForQuestionAnsweringSimple,
		    XLMForSequenceClassification,
		    XLMForTokenClassification,
		    XLMModel,
		    XLMWithLMHeadModel,
		)
		from transformers.models.xlm.modeling_xlm import XLM_PRETRAINED_MODEL_ARCHIVE_LIST




class 						a__							:





							'''simple docstring'''






							def __init__(						self   ,       lowerCamelCase_   ,       lowerCamelCase_=13   ,       lowerCamelCase_=7   ,       lowerCamelCase_=True   ,       lowerCamelCase_=True   ,       lowerCamelCase_=True   ,       lowerCamelCase_=True   ,       lowerCamelCase_=True   ,       lowerCamelCase_=False   ,       lowerCamelCase_=False   ,       lowerCamelCase_=False   ,       lowerCamelCase_=2   ,       lowerCamelCase_=99   ,       lowerCamelCase_=0   ,       lowerCamelCase_=32   ,       lowerCamelCase_=5   ,       lowerCamelCase_=4   ,       lowerCamelCase_=0.1   ,       lowerCamelCase_=0.1   ,       lowerCamelCase_=5_12   ,       lowerCamelCase_=2   ,       lowerCamelCase_=0.02   ,       lowerCamelCase_=2   ,       lowerCamelCase_=4   ,       lowerCamelCase_="last"   ,       lowerCamelCase_=True   ,       lowerCamelCase_=None   ,       lowerCamelCase_=0   ,       )			->				List[str]:
														lowerCAmelCase__			  =      parent
														lowerCAmelCase__			  =      batch_size
														lowerCAmelCase__			  =      seq_length
														lowerCAmelCase__			  =      is_training
														lowerCAmelCase__			  =      use_input_lengths
														lowerCAmelCase__			  =      use_token_type_ids
														lowerCAmelCase__			  =      use_labels
														lowerCAmelCase__			  =      gelu_activation
														lowerCAmelCase__			  =      sinusoidal_embeddings
														lowerCAmelCase__			  =      causal
														lowerCAmelCase__			  =      asm
														lowerCAmelCase__			  =      n_langs
														lowerCAmelCase__			  =      vocab_size
														lowerCAmelCase__			  =      n_special
														lowerCAmelCase__			  =      hidden_size
														lowerCAmelCase__			  =      num_hidden_layers
														lowerCAmelCase__			  =      num_attention_heads
														lowerCAmelCase__			  =      hidden_dropout_prob
														lowerCAmelCase__			  =      attention_probs_dropout_prob
														lowerCAmelCase__			  =      max_position_embeddings
														lowerCAmelCase__			  =      type_sequence_label_size
														lowerCAmelCase__			  =      initializer_range
														lowerCAmelCase__			  =      num_labels
														lowerCAmelCase__			  =      num_choices
														lowerCAmelCase__			  =      summary_type
														lowerCAmelCase__			  =      use_proj
														lowerCAmelCase__			  =      scope
														lowerCAmelCase__			  =      bos_token_id







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				str:
														lowerCAmelCase__			  =      ids_tensor([self.batch_size, self.seq_length]   ,       self.vocab_size  )
														lowerCAmelCase__			  =      random_attention_mask([self.batch_size, self.seq_length]  )

														lowerCAmelCase__			  =      None
														if self.use_input_lengths:
																					lowerCAmelCase__			  =      (
																					    ids_tensor([self.batch_size]   ,       vocab_size=2  ) + self.seq_length - 2
																					)  # small variation of seq_length

														lowerCAmelCase__			  =      None
														if self.use_token_type_ids:
																					lowerCAmelCase__			  =      ids_tensor([self.batch_size, self.seq_length]   ,       self.n_langs  )

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

														lowerCAmelCase__			  =      self.get_config()

														return (
														    config,
														    input_ids,
														    token_type_ids,
														    input_lengths,
														    sequence_labels,
														    token_labels,
														    is_impossible_labels,
														    choice_labels,
														    input_mask,
														)







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Dict:
														return 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   ,       num_labels=self.num_labels   ,       bos_token_id=self.bos_token_id   ,       )







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       )			->				Optional[Any]:
														lowerCAmelCase__			  =      XLMModel(config=lowerCamelCase_  )
														model.to(lowerCamelCase_  )
														model.eval()
														lowerCAmelCase__			  =      model(lowerCamelCase_   ,       lengths=lowerCamelCase_   ,       langs=lowerCamelCase_  )
														lowerCAmelCase__			  =      model(lowerCamelCase_   ,       langs=lowerCamelCase_  )
														lowerCAmelCase__			  =      model(lowerCamelCase_  )
														self.parent.assertEqual(result.last_hidden_state.shape   ,       (self.batch_size, self.seq_length, self.hidden_size)  )







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       )			->				Optional[Any]:
														lowerCAmelCase__			  =      XLMWithLMHeadModel(lowerCamelCase_  )
														model.to(lowerCamelCase_  )
														model.eval()

														lowerCAmelCase__			  =      model(lowerCamelCase_   ,       token_type_ids=lowerCamelCase_   ,       labels=lowerCamelCase_  )
														self.parent.assertEqual(result.loss.shape   ,       ()  )
														self.parent.assertEqual(result.logits.shape   ,       (self.batch_size, self.seq_length, self.vocab_size)  )







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       )			->				Dict:
														lowerCAmelCase__			  =      XLMForQuestionAnsweringSimple(lowerCamelCase_  )
														model.to(lowerCamelCase_  )
														model.eval()

														lowerCAmelCase__			  =      model(lowerCamelCase_  )

														lowerCAmelCase__			  =      model(lowerCamelCase_   ,       start_positions=lowerCamelCase_   ,       end_positions=lowerCamelCase_  )
														lowerCAmelCase__			  =      outputs
														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     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       )			->				str:
														lowerCAmelCase__			  =      XLMForQuestionAnswering(lowerCamelCase_  )
														model.to(lowerCamelCase_  )
														model.eval()

														lowerCAmelCase__			  =      model(lowerCamelCase_  )

														lowerCAmelCase__			  =      model(
														    lowerCamelCase_   ,       start_positions=lowerCamelCase_   ,       end_positions=lowerCamelCase_   ,       cls_index=lowerCamelCase_   ,       is_impossible=lowerCamelCase_   ,       p_mask=lowerCamelCase_   ,       )

														lowerCAmelCase__			  =      model(
														    lowerCamelCase_   ,       start_positions=lowerCamelCase_   ,       end_positions=lowerCamelCase_   ,       cls_index=lowerCamelCase_   ,       is_impossible=lowerCamelCase_   ,       )

														((lowerCAmelCase__)  ,   )			  =      result_with_labels.to_tuple()

														lowerCAmelCase__			  =      model(lowerCamelCase_   ,       start_positions=lowerCamelCase_   ,       end_positions=lowerCamelCase_  )

														((lowerCAmelCase__)  ,   )			  =      result_with_labels.to_tuple()

														self.parent.assertEqual(result_with_labels.loss.shape   ,       ()  )
														self.parent.assertEqual(result.start_top_log_probs.shape   ,       (self.batch_size, model.config.start_n_top)  )
														self.parent.assertEqual(result.start_top_index.shape   ,       (self.batch_size, model.config.start_n_top)  )
														self.parent.assertEqual(
														    result.end_top_log_probs.shape   ,       (self.batch_size, model.config.start_n_top * model.config.end_n_top)  )
														self.parent.assertEqual(
														    result.end_top_index.shape   ,       (self.batch_size, model.config.start_n_top * model.config.end_n_top)  )
														self.parent.assertEqual(result.cls_logits.shape   ,       (self.batch_size,)  )







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       )			->				Optional[int]:
														lowerCAmelCase__			  =      XLMForSequenceClassification(lowerCamelCase_  )
														model.to(lowerCamelCase_  )
														model.eval()

														lowerCAmelCase__			  =      model(lowerCamelCase_  )
														lowerCAmelCase__			  =      model(lowerCamelCase_   ,       labels=lowerCamelCase_  )
														self.parent.assertEqual(result.loss.shape   ,       ()  )
														self.parent.assertEqual(result.logits.shape   ,       (self.batch_size, self.type_sequence_label_size)  )







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       )			->				List[str]:
														lowerCAmelCase__			  =      self.num_labels
														lowerCAmelCase__			  =      XLMForTokenClassification(lowerCamelCase_  )
														model.to(lowerCamelCase_  )
														model.eval()

														lowerCAmelCase__			  =      model(lowerCamelCase_   ,       attention_mask=lowerCamelCase_   ,       labels=lowerCamelCase_  )
														self.parent.assertEqual(result.logits.shape   ,       (self.batch_size, self.seq_length, self.num_labels)  )







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       )			->				List[str]:
														lowerCAmelCase__			  =      self.num_choices
														lowerCAmelCase__			  =      XLMForMultipleChoice(config=lowerCamelCase_  )
														model.to(lowerCamelCase_  )
														model.eval()
														lowerCAmelCase__			  =      input_ids.unsqueeze(1  ).expand(-1   ,       self.num_choices   ,       -1  ).contiguous()
														lowerCAmelCase__			  =      token_type_ids.unsqueeze(1  ).expand(-1   ,       self.num_choices   ,       -1  ).contiguous()
														lowerCAmelCase__			  =      input_mask.unsqueeze(1  ).expand(-1   ,       self.num_choices   ,       -1  ).contiguous()
														lowerCAmelCase__			  =      model(
														    lowerCamelCase_   ,       attention_mask=lowerCamelCase_   ,       token_type_ids=lowerCamelCase_   ,       labels=lowerCamelCase_   ,       )
														self.parent.assertEqual(result.logits.shape   ,       (self.batch_size, self.num_choices)  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				str:
														lowerCAmelCase__			  =      self.prepare_config_and_inputs()
														(
														    (
														    lowerCAmelCase__
														)  ,   (
														    lowerCAmelCase__
														)  ,   (
														    lowerCAmelCase__
														)  ,   (
														    lowerCAmelCase__
														)  ,   (
														    lowerCAmelCase__
														)  ,   (
														    lowerCAmelCase__
														)  ,   (
														    lowerCAmelCase__
														)  ,   (
														    lowerCAmelCase__
														)  ,   (
														    lowerCAmelCase__
														)  ,   
														)			  =      config_and_inputs
														lowerCAmelCase__			  =      {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''lengths''': input_lengths}
														return config, inputs_dict




@require_torch
class 						a__							(				a__							,							a__							,							a__							,							unittest.TestCase    ):





							'''simple docstring'''






							lowercase__     :  List[Any]      		= (
							    (
							        XLMModel,
							        XLMWithLMHeadModel,
							        XLMForQuestionAnswering,
							        XLMForSequenceClassification,
							        XLMForQuestionAnsweringSimple,
							        XLMForTokenClassification,
							        XLMForMultipleChoice,
							    )
							    if is_torch_available()
							    else ()
							)
							lowercase__     :  int      		= (
							    (XLMWithLMHeadModel,) if is_torch_available() else ()
							)  # TODO (PVP): Check other models whether language generation is also applicable
							lowercase__     :  Tuple      		= (
							    {
							        "feature-extraction": XLMModel,
							        "fill-mask": XLMWithLMHeadModel,
							        "question-answering": XLMForQuestionAnsweringSimple,
							        "text-classification": XLMForSequenceClassification,
							        "text-generation": XLMWithLMHeadModel,
							        "token-classification": XLMForTokenClassification,
							        "zero-shot": XLMForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_  )			->				List[Any]:
														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     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_=False  )			->				List[str]:
														lowerCAmelCase__			  =      super()._prepare_for_class(lowerCamelCase_   ,       lowerCamelCase_   ,       return_labels=lowerCamelCase_  )

														if return_labels:
																					if model_class.__name__ == "XLMForQuestionAnswering":
																												lowerCAmelCase__			  =      torch.zeros(
																												    self.model_tester.batch_size   ,       dtype=torch.long   ,       device=lowerCamelCase_  )
																												lowerCAmelCase__			  =      torch.zeros(
																												    self.model_tester.batch_size   ,       dtype=torch.long   ,       device=lowerCamelCase_  )

														return inputs_dict







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[Any]:
														lowerCAmelCase__			  =      XLMModelTester(self  )
														lowerCAmelCase__			  =      ConfigTester(self   ,       config_class=lowerCamelCase_   ,       emb_dim=37  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[Any]:
														self.config_tester.run_common_tests()







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Tuple:
														lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_xlm_model(*lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[Any]:
														lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_xlm_lm_head(*lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				str:
														lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_xlm_simple_qa(*lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[int]:
														lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_xlm_qa(*lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_xlm_sequence_classif(*lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[str]:
														lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_xlm_token_classif(*lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[str]:
														lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_xlm_for_multiple_choice(*lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_=False   ,       lowerCamelCase_=1  )			->				Optional[int]:
														self.assertIsInstance(lowerCamelCase_   ,       lowerCamelCase_  )
														self.assertListEqual(
														    [isinstance(lowerCamelCase_   ,       lowerCamelCase_  ) for iter_attentions in attentions]   ,       [True] * len(lowerCamelCase_  )  )
														self.assertEqual(len(lowerCamelCase_  )   ,       (max_length - min_length) * num_beam_groups  )

														for idx, iter_attentions in enumerate(lowerCamelCase_  ):
																					# adds PAD dummy token
																					lowerCAmelCase__			  =      min_length + idx + 1
																					lowerCAmelCase__			  =      min_length + idx + 1

																					lowerCAmelCase__			  =      (
																					    batch_size * num_beam_groups,
																					    config.num_attention_heads,
																					    tgt_len,
																					    src_len,
																					)
																					# check attn size
																					self.assertListEqual(
																					    [layer_attention.shape for layer_attention in iter_attentions]   ,       [expected_shape] * len(lowerCamelCase_  )  )







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_=False   ,       lowerCamelCase_=1  )			->				int:
														self.assertIsInstance(lowerCamelCase_   ,       lowerCamelCase_  )
														self.assertListEqual(
														    [isinstance(lowerCamelCase_   ,       lowerCamelCase_  ) for iter_hidden_states in hidden_states]   ,       [True] * len(lowerCamelCase_  )   ,       )
														self.assertEqual(len(lowerCamelCase_  )   ,       (max_length - min_length) * num_beam_groups  )

														for idx, iter_hidden_states in enumerate(lowerCamelCase_  ):
																					# adds PAD dummy token
																					lowerCAmelCase__			  =      min_length + idx + 1
																					lowerCAmelCase__			  =      (batch_size * num_beam_groups, seq_len, config.hidden_size)
																					# check hidden size
																					self.assertListEqual(
																					    [layer_hidden_states.shape for layer_hidden_states in iter_hidden_states]   ,       [expected_shape] * len(lowerCamelCase_  )   ,       )
														pass







							@slow
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				str:
														for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					lowerCAmelCase__			  =      XLMModel.from_pretrained(lowerCamelCase_  )
																					self.assertIsNotNone(lowerCamelCase_  )




@require_torch
class 						a__							(				unittest.TestCase    ):





							'''simple docstring'''






							@slow
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				int:
														lowerCAmelCase__			  =      XLMWithLMHeadModel.from_pretrained('''xlm-mlm-en-2048'''  )
														model.to(lowerCamelCase_  )
														lowerCAmelCase__			  =      torch.tensor([[14, 4_47]]   ,       dtype=torch.long   ,       device=lowerCamelCase_  )  # the president
														lowerCAmelCase__			  =      [
														    14,
														    4_47,
														    14,
														    4_47,
														    14,
														    4_47,
														    14,
														    4_47,
														    14,
														    4_47,
														    14,
														    4_47,
														    14,
														    4_47,
														    14,
														    4_47,
														    14,
														    4_47,
														    14,
														    4_47,
														]  # 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__			  =      model.generate(lowerCamelCase_   ,       do_sample=lowerCamelCase_  )
														self.assertListEqual(output_ids[0].cpu().numpy().tolist()   ,       lowerCamelCase_  )
"""simple docstring"""




from collections.abc import Generator







def 				_UpperCAmelCase		(							):





		"""simple docstring"""




		lowerCAmelCase__ ,       lowerCAmelCase__   = 0, 1
		while True:
				lowerCAmelCase__ ,       lowerCAmelCase__   = b, a + b
				yield b







def 				_UpperCAmelCase		(							lowerCamelCase__ = 1000  ):





		"""simple docstring"""




		lowerCAmelCase__   = 1
		lowerCAmelCase__   = fibonacci_generator()
		while len(str(next(lowerCamelCase__  )  )  ) < n:
				answer += 1
		return answer + 1


if __name__ == "__main__":
			print(solution(int(str(input()).strip())))




