
"""simple docstring"""
import unittest

from transformers import AutoConfig, AutoTokenizer, BertConfig, TensorType, is_flax_available
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, slow


if is_flax_available():
			import jax

			from transformers.models.auto.modeling_flax_auto import FlaxAutoModel
			from transformers.models.bert.modeling_flax_bert import FlaxBertModel
			from transformers.models.roberta.modeling_flax_roberta import FlaxRobertaModel


@require_flax
class  _lowerCAmelCase    (    unittest.TestCase    ):



							@slow
							def    _a (   self )				->				str:
								for model_name in ["bert-base-cased", "bert-large-uncased"]:
									with self.subTest(snake_case__ ):
										_UpperCAmelCase			=    AutoConfig.from_pretrained(snake_case__ )
										self.assertIsNotNone(snake_case__ )
										self.assertIsInstance(snake_case__			,    snake_case__ )

										_UpperCAmelCase			=    FlaxAutoModel.from_pretrained(snake_case__ )
										self.assertIsNotNone(snake_case__ )
										self.assertIsInstance(snake_case__			,    snake_case__ )



							@slow
							def    _a (   self )				->				Optional[int]:
								for model_name in ["roberta-base", "roberta-large"]:
									with self.subTest(snake_case__ ):
										_UpperCAmelCase			=    AutoConfig.from_pretrained(snake_case__ )
										self.assertIsNotNone(snake_case__ )
										self.assertIsInstance(snake_case__			,    snake_case__ )

										_UpperCAmelCase			=    FlaxAutoModel.from_pretrained(snake_case__ )
										self.assertIsNotNone(snake_case__ )
										self.assertIsInstance(snake_case__			,    snake_case__ )



							@slow
							def    _a (   self )				->				List[str]:
								for model_name in ["bert-base-cased", "bert-large-uncased"]:
									_UpperCAmelCase			=    AutoTokenizer.from_pretrained(snake_case__ )
									_UpperCAmelCase			=    FlaxBertModel.from_pretrained(snake_case__ )
									_UpperCAmelCase			=    tokenizer("Do you support jax jitted function?"			,    return_tensors=TensorType.JAX )

									@jax.jit
									def eval(**a_ ):
										return model(**snake_case__ )

									eval(**snake_case__ ).block_until_ready()



							@slow
							def    _a (   self )				->				int:
								for model_name in ["roberta-base", "roberta-large"]:
									_UpperCAmelCase			=    AutoTokenizer.from_pretrained(snake_case__ )
									_UpperCAmelCase			=    FlaxRobertaModel.from_pretrained(snake_case__ )
									_UpperCAmelCase			=    tokenizer("Do you support jax jitted function?"			,    return_tensors=TensorType.JAX )

									@jax.jit
									def eval(**a_ ):
										return model(**snake_case__ )

									eval(**snake_case__ ).block_until_ready()



							def    _a (   self )				->				str:
								with self.assertRaisesRegex(
								    snake_case__			,    "bert-base is not a local folder and is not a valid model identifier" ):
									_UpperCAmelCase			=    FlaxAutoModel.from_pretrained("bert-base" )



							def    _a (   self )				->				Dict:
								with self.assertRaisesRegex(
								    snake_case__			,    r"aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)" ):
									_UpperCAmelCase			=    FlaxAutoModel.from_pretrained(snake_case__			,    revision="aaaaaa" )



							def    _a (   self )				->				int:
								with self.assertRaisesRegex(
								    snake_case__			,    "hf-internal-testing/config-no-model does not appear to have a file named flax_model.msgpack"			,    ):
									_UpperCAmelCase			=    FlaxAutoModel.from_pretrained("hf-internal-testing/config-no-model" )



							def    _a (   self )				->				Optional[int]:
								with self.assertRaisesRegex(snake_case__			,    "Use `from_pt=True` to load this model" ):
									_UpperCAmelCase			=    FlaxAutoModel.from_pretrained("hf-internal-testing/tiny-bert-pt-only" )












"""simple docstring"""



def 	SCREAMING_SNAKE_CASE__       (  snake_case       : list				)->		list:






     '''simple docstring'''



     UpperCAmelCase__						:    List[str]							=							False
     while is_sorted is False:  # Until all the indices are traversed keep looping
          UpperCAmelCase__						:    List[Any]							=							True
          for i in range(0			,					len(snake_case				) - 1			,					2				):  # iterating over all even indices
               if input_list[i] > input_list[i + 1]:
                    UpperCAmelCase__							,				UpperCAmelCase__						:    Optional[int]							=							input_list[i + 1], input_list[i]
                    # swapping if elements not in order
                    UpperCAmelCase__						:    int							=							False

          for i in range(1			,					len(snake_case				) - 1			,					2				):  # iterating over all odd indices
               if input_list[i] > input_list[i + 1]:
                    UpperCAmelCase__							,				UpperCAmelCase__						:    Optional[int]							=							input_list[i + 1], input_list[i]
                    # swapping if elements not in order
                    UpperCAmelCase__						:    str							=							False
     return input_list


if __name__ == "__main__":
 print("""Enter list to be sorted""")
 _lowerCAmelCase	:	List[str]				=      [int(x) for x in input().split()]
 # inputing elements of the list in one line
 _lowerCAmelCase	:	Optional[int]				=      odd_even_sort(input_list)
 print("""The sorted list is""")
 print(sorted_list)


