



import unittest

import numpy as np

from transformers.testing_utils import require_flax, require_tf, require_torch
from transformers.utils import (
    expand_dims,
    flatten_dict,
    is_flax_available,
    is_tf_available,
    is_torch_available,
    reshape,
    squeeze,
    transpose,
)


if is_flax_available():
							import jax.numpy as jnp

if is_tf_available():
							import tensorflow as tf

if is_torch_available():
							import torch
class 			_snake_case     (   unittest.TestCase):




				def 							A__ (  self   :  Dict  ):
							lowercase__   					=			{
							    "task_specific_params": {
							        "summarization": {"length_penalty": 1.0, "max_length": 128, "min_length": 12, "num_beams": 4},
							        "summarization_cnn": {"length_penalty": 2.0, "max_length": 142, "min_length": 56, "num_beams": 4},
							        "summarization_xsum": {"length_penalty": 1.0, "max_length": 62, "min_length": 11, "num_beams": 6},
							    }
							}
							lowercase__   					=			{
							    "task_specific_params.summarization.length_penalty": 1.0,
							    "task_specific_params.summarization.max_length": 128,
							    "task_specific_params.summarization.min_length": 12,
							    "task_specific_params.summarization.num_beams": 4,
							    "task_specific_params.summarization_cnn.length_penalty": 2.0,
							    "task_specific_params.summarization_cnn.max_length": 142,
							    "task_specific_params.summarization_cnn.min_length": 56,
							    "task_specific_params.summarization_cnn.num_beams": 4,
							    "task_specific_params.summarization_xsum.length_penalty": 1.0,
							    "task_specific_params.summarization_xsum.max_length": 62,
							    "task_specific_params.summarization_xsum.min_length": 11,
							    "task_specific_params.summarization_xsum.num_beams": 6,
							}

							self.assertEqual(flatten_dict(__lowercase  ),   __lowercase  )




				def 							A__ (  self   :  List[Any]  ):
							lowercase__   					=			np.random.randn(3,   4  )
							self.assertTrue(np.allclose(transpose(__lowercase  ),   x.transpose()  )  )

							lowercase__   					=			np.random.randn(3,   4,   5  )
							self.assertTrue(np.allclose(transpose(__lowercase,   axes=(1, 2, 0)  ),   x.transpose((1, 2, 0)  )  )  )




				@require_torch
				def 							A__ (  self   :  Dict  ):
							lowercase__   					=			np.random.randn(3,   4  )
							lowercase__   					=			torch.tensor(__lowercase  )
							self.assertTrue(np.allclose(transpose(__lowercase  ),   transpose(__lowercase  ).numpy()  )  )

							lowercase__   					=			np.random.randn(3,   4,   5  )
							lowercase__   					=			torch.tensor(__lowercase  )
							self.assertTrue(np.allclose(transpose(__lowercase,   axes=(1, 2, 0)  ),   transpose(__lowercase,   axes=(1, 2, 0)  ).numpy()  )  )




				@require_tf
				def 							A__ (  self   :  Optional[int]  ):
							lowercase__   					=			np.random.randn(3,   4  )
							lowercase__   					=			tf.constant(__lowercase  )
							self.assertTrue(np.allclose(transpose(__lowercase  ),   transpose(__lowercase  ).numpy()  )  )

							lowercase__   					=			np.random.randn(3,   4,   5  )
							lowercase__   					=			tf.constant(__lowercase  )
							self.assertTrue(np.allclose(transpose(__lowercase,   axes=(1, 2, 0)  ),   transpose(__lowercase,   axes=(1, 2, 0)  ).numpy()  )  )




				@require_flax
				def 							A__ (  self   :  List[Any]  ):
							lowercase__   					=			np.random.randn(3,   4  )
							lowercase__   					=			jnp.array(__lowercase  )
							self.assertTrue(np.allclose(transpose(__lowercase  ),   np.asarray(transpose(__lowercase  )  )  )  )

							lowercase__   					=			np.random.randn(3,   4,   5  )
							lowercase__   					=			jnp.array(__lowercase  )
							self.assertTrue(np.allclose(transpose(__lowercase,   axes=(1, 2, 0)  ),   np.asarray(transpose(__lowercase,   axes=(1, 2, 0)  )  )  )  )




				def 							A__ (  self   :  Any  ):
							lowercase__   					=			np.random.randn(3,   4  )
							self.assertTrue(np.allclose(reshape(__lowercase,   (4, 3)  ),   np.reshape(__lowercase,   (4, 3)  )  )  )

							lowercase__   					=			np.random.randn(3,   4,   5  )
							self.assertTrue(np.allclose(reshape(__lowercase,   (12, 5)  ),   np.reshape(__lowercase,   (12, 5)  )  )  )




				@require_torch
				def 							A__ (  self   :  Tuple  ):
							lowercase__   					=			np.random.randn(3,   4  )
							lowercase__   					=			torch.tensor(__lowercase  )
							self.assertTrue(np.allclose(reshape(__lowercase,   (4, 3)  ),   reshape(__lowercase,   (4, 3)  ).numpy()  )  )

							lowercase__   					=			np.random.randn(3,   4,   5  )
							lowercase__   					=			torch.tensor(__lowercase  )
							self.assertTrue(np.allclose(reshape(__lowercase,   (12, 5)  ),   reshape(__lowercase,   (12, 5)  ).numpy()  )  )




				@require_tf
				def 							A__ (  self   :  List[str]  ):
							lowercase__   					=			np.random.randn(3,   4  )
							lowercase__   					=			tf.constant(__lowercase  )
							self.assertTrue(np.allclose(reshape(__lowercase,   (4, 3)  ),   reshape(__lowercase,   (4, 3)  ).numpy()  )  )

							lowercase__   					=			np.random.randn(3,   4,   5  )
							lowercase__   					=			tf.constant(__lowercase  )
							self.assertTrue(np.allclose(reshape(__lowercase,   (12, 5)  ),   reshape(__lowercase,   (12, 5)  ).numpy()  )  )




				@require_flax
				def 							A__ (  self   :  Optional[Any]  ):
							lowercase__   					=			np.random.randn(3,   4  )
							lowercase__   					=			jnp.array(__lowercase  )
							self.assertTrue(np.allclose(reshape(__lowercase,   (4, 3)  ),   np.asarray(reshape(__lowercase,   (4, 3)  )  )  )  )

							lowercase__   					=			np.random.randn(3,   4,   5  )
							lowercase__   					=			jnp.array(__lowercase  )
							self.assertTrue(np.allclose(reshape(__lowercase,   (12, 5)  ),   np.asarray(reshape(__lowercase,   (12, 5)  )  )  )  )




				def 							A__ (  self   :  Any  ):
							lowercase__   					=			np.random.randn(1,   3,   4  )
							self.assertTrue(np.allclose(squeeze(__lowercase  ),   np.squeeze(__lowercase  )  )  )

							lowercase__   					=			np.random.randn(1,   4,   1,   5  )
							self.assertTrue(np.allclose(squeeze(__lowercase,   axis=2  ),   np.squeeze(__lowercase,   axis=2  )  )  )




				@require_torch
				def 							A__ (  self   :  str  ):
							lowercase__   					=			np.random.randn(1,   3,   4  )
							lowercase__   					=			torch.tensor(__lowercase  )
							self.assertTrue(np.allclose(squeeze(__lowercase  ),   squeeze(__lowercase  ).numpy()  )  )

							lowercase__   					=			np.random.randn(1,   4,   1,   5  )
							lowercase__   					=			torch.tensor(__lowercase  )
							self.assertTrue(np.allclose(squeeze(__lowercase,   axis=2  ),   squeeze(__lowercase,   axis=2  ).numpy()  )  )




				@require_tf
				def 							A__ (  self   :  str  ):
							lowercase__   					=			np.random.randn(1,   3,   4  )
							lowercase__   					=			tf.constant(__lowercase  )
							self.assertTrue(np.allclose(squeeze(__lowercase  ),   squeeze(__lowercase  ).numpy()  )  )

							lowercase__   					=			np.random.randn(1,   4,   1,   5  )
							lowercase__   					=			tf.constant(__lowercase  )
							self.assertTrue(np.allclose(squeeze(__lowercase,   axis=2  ),   squeeze(__lowercase,   axis=2  ).numpy()  )  )




				@require_flax
				def 							A__ (  self   :  Union[str, Any]  ):
							lowercase__   					=			np.random.randn(1,   3,   4  )
							lowercase__   					=			jnp.array(__lowercase  )
							self.assertTrue(np.allclose(squeeze(__lowercase  ),   np.asarray(squeeze(__lowercase  )  )  )  )

							lowercase__   					=			np.random.randn(1,   4,   1,   5  )
							lowercase__   					=			jnp.array(__lowercase  )
							self.assertTrue(np.allclose(squeeze(__lowercase,   axis=2  ),   np.asarray(squeeze(__lowercase,   axis=2  )  )  )  )




				def 							A__ (  self   :  Optional[int]  ):
							lowercase__   					=			np.random.randn(3,   4  )
							self.assertTrue(np.allclose(expand_dims(__lowercase,   axis=1  ),   np.expand_dims(__lowercase,   axis=1  )  )  )




				@require_torch
				def 							A__ (  self   :  List[Any]  ):
							lowercase__   					=			np.random.randn(3,   4  )
							lowercase__   					=			torch.tensor(__lowercase  )
							self.assertTrue(np.allclose(expand_dims(__lowercase,   axis=1  ),   expand_dims(__lowercase,   axis=1  ).numpy()  )  )




				@require_tf
				def 							A__ (  self   :  Optional[Any]  ):
							lowercase__   					=			np.random.randn(3,   4  )
							lowercase__   					=			tf.constant(__lowercase  )
							self.assertTrue(np.allclose(expand_dims(__lowercase,   axis=1  ),   expand_dims(__lowercase,   axis=1  ).numpy()  )  )




				@require_flax
				def 							A__ (  self   :  Tuple  ):
							lowercase__   					=			np.random.randn(3,   4  )
							lowercase__   					=			jnp.array(__lowercase  )
							self.assertTrue(np.allclose(expand_dims(__lowercase,   axis=1  ),   np.asarray(expand_dims(__lowercase,   axis=1  )  )  )  )









def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_					):
			lowercase__   					=			len(SCREAMING_SNAKE_CASE_					)
			for i in range(SCREAMING_SNAKE_CASE_					):
						for j in range(i + 1  ,					SCREAMING_SNAKE_CASE_					):
									if numbers[j] < numbers[i]:
												lowercase__					,    lowercase__   					=			numbers[j], numbers[i]
			return numbers


if __name__ == "__main__":
							lowercase_						=       input("""Enter numbers separated by a comma:\n""").strip()
							lowercase_						=       [int(item) for item in user_input.split(""",""")]
							print(exchange_sort(unsorted))




