





import unittest

from transformers.testing_utils import CaptureStdout
from transformers.tools.python_interpreter import evaluate






def 					SCREAMING_SNAKE_CASE__				(							UpperCamelCase__:				int     ):
		return x + 2




class 	UpperCamelCase_							(  unittest.TestCase     ):


							def   _snake_case	(				self     :Any		) -> str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   'x = 3'
									SCREAMING_SNAKE_CASE__								=   {}
									SCREAMING_SNAKE_CASE__								=   evaluate(snake_case__				,					{}				,					state=snake_case__		)
									assert result == 3
									self.assertDictEqual(snake_case__				,					{"""x""": 3}		)

									SCREAMING_SNAKE_CASE__								=   'x = y'
									SCREAMING_SNAKE_CASE__								=   {'y': 5}
									SCREAMING_SNAKE_CASE__								=   evaluate(snake_case__				,					{}				,					state=snake_case__		)
									# evaluate returns the value of the last assignment.
									assert result == 5
									self.assertDictEqual(snake_case__				,					{"""x""": 5, """y""": 5}		)


							def   _snake_case	(				self     :List[Any]		) -> int:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   'y = add_two(x)'
									SCREAMING_SNAKE_CASE__								=   {'x': 3}
									SCREAMING_SNAKE_CASE__								=   evaluate(snake_case__				,					{"""add_two""": add_two}				,					state=snake_case__		)
									assert result == 5
									self.assertDictEqual(snake_case__				,					{"""x""": 3, """y""": 5}		)

									# Won't work without the tool
									with CaptureStdout() as out:
											SCREAMING_SNAKE_CASE__								=   evaluate(snake_case__				,					{}				,					state=snake_case__		)
									assert result is None
									assert "tried to execute add_two" in out.out


							def   _snake_case	(				self     :Union[str, Any]		) -> Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   'x = 3'
									SCREAMING_SNAKE_CASE__								=   {}
									SCREAMING_SNAKE_CASE__								=   evaluate(snake_case__				,					{}				,					state=snake_case__		)
									assert result == 3
									self.assertDictEqual(snake_case__				,					{"""x""": 3}		)


							def   _snake_case	(				self     :int		) -> Optional[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   'test_dict = {\'x\': x, \'y\': add_two(x)}'
									SCREAMING_SNAKE_CASE__								=   {'x': 3}
									SCREAMING_SNAKE_CASE__								=   evaluate(snake_case__				,					{"""add_two""": add_two}				,					state=snake_case__		)
									self.assertDictEqual(snake_case__				,					{"""x""": 3, """y""": 5}		)
									self.assertDictEqual(snake_case__				,					{"""x""": 3, """test_dict""": {"""x""": 3, """y""": 5}}		)


							def   _snake_case	(				self     :str		) -> Union[str, Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   'x = 3\ny = 5'
									SCREAMING_SNAKE_CASE__								=   {}
									SCREAMING_SNAKE_CASE__								=   evaluate(snake_case__				,					{}				,					state=snake_case__		)
									# evaluate returns the value of the last assignment.
									assert result == 5
									self.assertDictEqual(snake_case__				,					{"""x""": 3, """y""": 5}		)


							def   _snake_case	(				self     :Union[str, Any]		) -> List[str]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   'text = f\'This is x: {x}.\''
									SCREAMING_SNAKE_CASE__								=   {'x': 3}
									SCREAMING_SNAKE_CASE__								=   evaluate(snake_case__				,					{}				,					state=snake_case__		)
									# evaluate returns the value of the last assignment.
									assert result == "This is x: 3."
									self.assertDictEqual(snake_case__				,					{"""x""": 3, """text""": """This is x: 3."""}		)


							def   _snake_case	(				self     :Tuple		) -> Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   'if x <= 3:\n    y = 2\nelse:\n    y = 5'
									SCREAMING_SNAKE_CASE__								=   {'x': 3}
									SCREAMING_SNAKE_CASE__								=   evaluate(snake_case__				,					{}				,					state=snake_case__		)
									# evaluate returns the value of the last assignment.
									assert result == 2
									self.assertDictEqual(snake_case__				,					{"""x""": 3, """y""": 2}		)

									SCREAMING_SNAKE_CASE__								=   {'x': 8}
									SCREAMING_SNAKE_CASE__								=   evaluate(snake_case__				,					{}				,					state=snake_case__		)
									# evaluate returns the value of the last assignment.
									assert result == 5
									self.assertDictEqual(snake_case__				,					{"""x""": 8, """y""": 5}		)


							def   _snake_case	(				self     :int		) -> Dict:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   'test_list = [x, add_two(x)]'
									SCREAMING_SNAKE_CASE__								=   {'x': 3}
									SCREAMING_SNAKE_CASE__								=   evaluate(snake_case__				,					{"""add_two""": add_two}				,					state=snake_case__		)
									self.assertListEqual(snake_case__				,					[3, 5]		)
									self.assertDictEqual(snake_case__				,					{"""x""": 3, """test_list""": [3, 5]}		)


							def   _snake_case	(				self     :Union[str, Any]		) -> str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   'y = x'
									SCREAMING_SNAKE_CASE__								=   {'x': 3}
									SCREAMING_SNAKE_CASE__								=   evaluate(snake_case__				,					{}				,					state=snake_case__		)
									assert result == 3
									self.assertDictEqual(snake_case__				,					{"""x""": 3, """y""": 3}		)


							def   _snake_case	(				self     :List[str]		) -> List[str]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   'test_list = [x, add_two(x)]\ntest_list[1]'
									SCREAMING_SNAKE_CASE__								=   {'x': 3}
									SCREAMING_SNAKE_CASE__								=   evaluate(snake_case__				,					{"""add_two""": add_two}				,					state=snake_case__		)
									assert result == 5
									self.assertDictEqual(snake_case__				,					{"""x""": 3, """test_list""": [3, 5]}		)

									SCREAMING_SNAKE_CASE__								=   'test_dict = {\'x\': x, \'y\': add_two(x)}\ntest_dict[\'y\']'
									SCREAMING_SNAKE_CASE__								=   {'x': 3}
									SCREAMING_SNAKE_CASE__								=   evaluate(snake_case__				,					{"""add_two""": add_two}				,					state=snake_case__		)
									assert result == 5
									self.assertDictEqual(snake_case__				,					{"""x""": 3, """test_dict""": {"""x""": 3, """y""": 5}}		)


							def   _snake_case	(				self     :Optional[Any]		) -> List[str]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   'x = 0\nfor i in range(3):\n    x = i'
									SCREAMING_SNAKE_CASE__								=   {}
									SCREAMING_SNAKE_CASE__								=   evaluate(snake_case__				,					{"""range""": range}				,					state=snake_case__		)
									assert result == 2
									self.assertDictEqual(snake_case__				,					{"""x""": 2, """i""": 2}		)



'''simple docstring'''







def       lowercase					(_A       ):







       """simple docstring"""







       _lowerCAmelCase     :				Union[str, Any]       =							len(_A       )
       for i in range(length - 1       ):
              _lowerCAmelCase     :				List[Any]       =							i
              for k in range(i + 1 ,    _A       ):
                     if collection[k] < collection[least]:
                            _lowerCAmelCase     :				List[str]       =							k
              if least != i:
                     _lowerCAmelCase      ,  _lowerCAmelCase     :				Union[str, Any]       =							(collection[i], collection[least])
       return collection


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

