


"""simple docstring"""
def     _a					(   _SCREAMING_SNAKE_CASE					)     ->					str:
							snake_case_     							=		[701, 301, 132, 57, 23, 10, 4, 1]
							for gap in gaps:
														for i in range(_SCREAMING_SNAKE_CASE					,			len(_SCREAMING_SNAKE_CASE					)					):
																					snake_case_     							=		collection[i]
																					snake_case_     							=		i
																					while j >= gap and collection[j - gap] > insert_value:
																												snake_case_     							=		collection[j - gap]
																												j -= gap
																					if j != i:
																												snake_case_     							=		insert_value
							return collection


if __name__ == "__main__":
				from doctest import testmod

				testmod()
				__SCREAMING_SNAKE_CASE				:     Optional[Any]		=     input('Enter numbers separated by a comma:\n').strip()
				__SCREAMING_SNAKE_CASE				:     Union[str, Any]		=     [int(item) for item in user_input.split(',')]
				print(shell_sort(unsorted))





'''simple docstring'''






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 							_snake_case     :
	"""simple docstring"""





	def __init__(						self				: str					,						UpperCamelCase_				: Union[str, Any]					,						):
			lowerCAmelCase_   :       Optional[Any]    							=parent
			lowerCAmelCase_   :       Any    							=13
			lowerCAmelCase_   :       str    							=7
			lowerCAmelCase_   :       Optional[Any]    							=True
			lowerCAmelCase_   :       Optional[int]    							=True
			lowerCAmelCase_   :       List[str]    							=True
			lowerCAmelCase_   :       Optional[int]    							=True
			lowerCAmelCase_   :       Dict    							=True
			lowerCAmelCase_   :       Union[str, Any]    							=False
			lowerCAmelCase_   :       List[Any]    							=False
			lowerCAmelCase_   :       Optional[int]    							=False
			lowerCAmelCase_   :       Union[str, Any]    							=2
			lowerCAmelCase_   :       List[str]    							=99
			lowerCAmelCase_   :       Optional[int]    							=0
			lowerCAmelCase_   :       Optional[int]    							=32
			lowerCAmelCase_   :       Dict    							=2
			lowerCAmelCase_   :       Dict    							=4
			lowerCAmelCase_   :       Tuple    							=0.1
			lowerCAmelCase_   :       Tuple    							=0.1
			lowerCAmelCase_   :       Tuple    							=512
			lowerCAmelCase_   :       Dict    							=16
			lowerCAmelCase_   :       List[Any]    							=2
			lowerCAmelCase_   :       Optional[int]    							=0.0_2
			lowerCAmelCase_   :       int    							=3
			lowerCAmelCase_   :       int    							=4
			lowerCAmelCase_   :       Union[str, Any]    							='''last'''
			lowerCAmelCase_   :       Optional[int]    							=True
			lowerCAmelCase_   :       Any    							=None
			lowerCAmelCase_   :       int    							=0




	def 	__A      (						self				: Dict      ):
			lowerCAmelCase_   :       List[Any]    							=ids_tensor([self.batch_size, self.seq_length]					,						self.vocab_size      )
			lowerCAmelCase_   :       Union[str, Any]    							=random_attention_mask([self.batch_size, self.seq_length]					,						dtype=tf.floataa      )

			lowerCAmelCase_   :       List[str]    							=None
			if self.use_input_lengths:
					lowerCAmelCase_   :       Optional[Any]    							=(
					    ids_tensor([self.batch_size]					,						vocab_size=2      ) + self.seq_length - 2
					)  # small variation of seq_length

			lowerCAmelCase_   :       str    							=None
			if self.use_token_type_ids:
					lowerCAmelCase_   :       Optional[Any]    							=ids_tensor([self.batch_size, self.seq_length]					,						self.n_langs      )

			lowerCAmelCase_   :       Optional[int]    							=None
			lowerCAmelCase_   :       str    							=None
			lowerCAmelCase_   :       Dict    							=None
			if self.use_labels:
					lowerCAmelCase_   :       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_   :       int    							=ids_tensor([self.batch_size]					,						2					,						dtype=tf.floataa      )
					lowerCAmelCase_   :       Optional[Any]    							=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				: Any					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Tuple					,						):
			lowerCAmelCase_   :       int    							=TFXLMModel(config=UpperCamelCase_      )
			lowerCAmelCase_   :       Optional[int]    							={'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
			lowerCAmelCase_   :       Union[str, Any]    							=model(UpperCamelCase_      )

			lowerCAmelCase_   :       Union[str, Any]    							=[input_ids, input_mask]
			lowerCAmelCase_   :       List[Any]    							=model(UpperCamelCase_      )
			self.parent.assertEqual(result.last_hidden_state.shape					,						(self.batch_size, self.seq_length, self.hidden_size)      )




	def 	__A      (						self				: List[Any]					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: List[Any]					,						):
			lowerCAmelCase_   :       List[str]    							=TFXLMWithLMHeadModel(UpperCamelCase_      )

			lowerCAmelCase_   :       List[Any]    							={'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
			lowerCAmelCase_   :       Tuple    							=model(UpperCamelCase_      )

			lowerCAmelCase_   :       int    							=outputs

			self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.seq_length, self.vocab_size)      )




	def 	__A      (						self				: int					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: Optional[int]					,						UpperCamelCase_				: Any					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: str					,						UpperCamelCase_				: Optional[int]					,						):
			lowerCAmelCase_   :       Optional[Any]    							=TFXLMForQuestionAnsweringSimple(UpperCamelCase_      )

			lowerCAmelCase_   :       str    							={'''input_ids''': input_ids, '''lengths''': input_lengths}

			lowerCAmelCase_   :       Optional[Any]    							=model(UpperCamelCase_      )

			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				: Tuple					,						UpperCamelCase_				: Any					,						UpperCamelCase_				: Optional[int]					,						UpperCamelCase_				: str					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: List[Any]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Optional[int]					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: Optional[int]					,						):
			lowerCAmelCase_   :       List[Any]    							=TFXLMForSequenceClassification(UpperCamelCase_      )

			lowerCAmelCase_   :       List[Any]    							={'''input_ids''': input_ids, '''lengths''': input_lengths}

			lowerCAmelCase_   :       int    							=model(UpperCamelCase_      )

			self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.type_sequence_label_size)      )




	def 	__A      (						self				: List[str]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Any					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Optional[int]					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Optional[int]					,						):
			lowerCAmelCase_   :       Optional[Any]    							=self.num_labels
			lowerCAmelCase_   :       int    							=TFXLMForTokenClassification(config=UpperCamelCase_      )
			lowerCAmelCase_   :       Optional[int]    							={'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
			lowerCAmelCase_   :       str    							=model(UpperCamelCase_      )
			self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.seq_length, self.num_labels)      )




	def 	__A      (						self				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: str					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: Optional[int]					,						):
			lowerCAmelCase_   :       List[str]    							=self.num_choices
			lowerCAmelCase_   :       Tuple    							=TFXLMForMultipleChoice(config=UpperCamelCase_      )
			lowerCAmelCase_   :       str    							=tf.tile(tf.expand_dims(UpperCamelCase_					,						1      )					,						(1, self.num_choices, 1)      )
			lowerCAmelCase_   :       Union[str, Any]    							=tf.tile(tf.expand_dims(UpperCamelCase_					,						1      )					,						(1, self.num_choices, 1)      )
			lowerCAmelCase_   :       Any    							=tf.tile(tf.expand_dims(UpperCamelCase_					,						1      )					,						(1, self.num_choices, 1)      )
			lowerCAmelCase_   :       Optional[Any]    							={
			    '''input_ids''': multiple_choice_inputs_ids,
			    '''attention_mask''': multiple_choice_input_mask,
			    '''token_type_ids''': multiple_choice_token_type_ids,
			}
			lowerCAmelCase_   :       Any    							=model(UpperCamelCase_      )
			self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.num_choices)      )





	def 	__A      (						self				: Union[str, Any]      ):
			lowerCAmelCase_   :       List[Any]    							=self.prepare_config_and_inputs()
			(
			    (
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		
			)   :       List[str]    							=config_and_inputs
			lowerCAmelCase_   :       List[Any]    							={
			    '''input_ids''': input_ids,
			    '''token_type_ids''': token_type_ids,
			    '''langs''': token_type_ids,
			    '''lengths''': input_lengths,
			}
			return config, inputs_dict







@require_tf
class 							_snake_case     (  lowerCAmelCase_						,    lowerCAmelCase_						,    unittest.TestCase ):
	"""simple docstring"""





	_UpperCamelCase							:  Union[str, Any]								=		(
	    (
	        TFXLMModel,
	        TFXLMWithLMHeadModel,
	        TFXLMForSequenceClassification,
	        TFXLMForQuestionAnsweringSimple,
	        TFXLMForTokenClassification,
	        TFXLMForMultipleChoice,
	    )
	    if is_tf_available()
	    else ()
	)
	_UpperCamelCase							:  Union[str, Any]								=		(
	    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
	)  # TODO (PVP): Check other models whether language generation is also applicable
	_UpperCamelCase							:  List[str]								=		(
	    {
	        '''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 {}
	)
	_UpperCamelCase							:  Optional[int]								=		False
	_UpperCamelCase							:  int								=		False




	def 	__A      (						self				: Optional[Any]					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: List[str]      ):
			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				: List[Any]      ):
			lowerCAmelCase_   :       Union[str, Any]    							=TFXLMModelTester(self      )
			lowerCAmelCase_   :       Optional[Any]    							=ConfigTester(self					,						config_class=UpperCamelCase_					,						emb_dim=37      )




	def 	__A      (						self				: Union[str, Any]      ):
			self.config_tester.run_common_tests()




	def 	__A      (						self				: int      ):
			lowerCAmelCase_   :       List[str]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_model(*UpperCamelCase_      )




	def 	__A      (						self				: Optional[int]      ):
			lowerCAmelCase_   :       Optional[int]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_lm_head(*UpperCamelCase_      )




	def 	__A      (						self				: Optional[Any]      ):
			lowerCAmelCase_   :       int    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_qa(*UpperCamelCase_      )




	def 	__A      (						self				: int      ):
			lowerCAmelCase_   :       Optional[int]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_sequence_classif(*UpperCamelCase_      )




	def 	__A      (						self				: Optional[int]      ):
			lowerCAmelCase_   :       Optional[int]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_for_token_classification(*UpperCamelCase_      )




	def 	__A      (						self				: List[Any]      ):
			lowerCAmelCase_   :       List[str]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_for_multiple_choice(*UpperCamelCase_      )





	@slow
	def 	__A      (						self				: List[Any]      ):
			for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowerCAmelCase_   :       List[str]    							=TFXLMModel.from_pretrained(UpperCamelCase_      )
					self.assertIsNotNone(UpperCamelCase_      )







@require_tf
class 							_snake_case     (  unittest.TestCase ):
	"""simple docstring"""





	@slow
	def 	__A      (						self				: Dict      ):
			lowerCAmelCase_   :       Any    							=TFXLMWithLMHeadModel.from_pretrained('''xlm-mlm-en-2048'''      )
			lowerCAmelCase_   :       List[str]    							=tf.convert_to_tensor([[14, 447]]					,						dtype=tf.intaa      )  # the president
			lowerCAmelCase_   :       List[Any]    							=[
			    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_   :       Optional[int]    							=model.generate(UpperCamelCase_					,						do_sample=UpperCamelCase_      )
			self.assertListEqual(output_ids[0].numpy().tolist()					,						UpperCamelCase_      )






