



'''simple docstring'''







import unittest
from dataclasses import dataclass
from typing import Optional

from transformers.utils import ModelOutput




@dataclass
class 				__lowerCAmelCase(							lowerCAmelCase__      ):
			__snake_case  :		float
			__snake_case  :		Optional[float]		=      None
			__snake_case  :		Optional[float]		=      None




class 				__lowerCAmelCase(							unittest.TestCase      ):






			def 				_lowercase	(   self  :							Tuple	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:int										=      ModelOutputTest(a=30	)
					self.assertEqual(x.a      ,       30	)
					self.assertIsNone(x.b	)
					self.assertIsNone(x.c	)
					with self.assertRaises(SCREAMING_SNAKE_CASE	):
							SCREAMING_SNAKE_CASE_						:Optional[Any]										=      x.d






			def 				_lowercase	(   self  :							Dict	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Tuple										=      ModelOutputTest(a=30      ,       b=10	)
					self.assertEqual(x[0]      ,       30	)
					self.assertEqual(x[1]      ,       10	)
					self.assertEqual(x[:2]      ,       (30, 10)	)
					self.assertEqual(x[:]      ,       (30, 10)	)

					SCREAMING_SNAKE_CASE_						:Any										=      ModelOutputTest(a=30      ,       c=10	)
					self.assertEqual(x[0]      ,       30	)
					self.assertEqual(x[1]      ,       10	)
					self.assertEqual(x[:2]      ,       (30, 10)	)
					self.assertEqual(x[:]      ,       (30, 10)	)






			def 				_lowercase	(   self  :							int	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Any										=      ModelOutputTest(a=30      ,       b=10	)
					self.assertEqual(x['a']      ,       30	)
					self.assertEqual(x['b']      ,       10	)
					with self.assertRaises(SCREAMING_SNAKE_CASE	):
							SCREAMING_SNAKE_CASE_						:str										=      x['c']

					SCREAMING_SNAKE_CASE_						:Optional[Any]										=      ModelOutputTest(a=30      ,       c=10	)
					self.assertEqual(x['a']      ,       30	)
					self.assertEqual(x['c']      ,       10	)
					with self.assertRaises(SCREAMING_SNAKE_CASE	):
							SCREAMING_SNAKE_CASE_						:List[str]										=      x['b']






			def 				_lowercase	(   self  :							Dict	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      ModelOutputTest(a=30	)
					self.assertEqual(list(x.keys()	)      ,       ['a']	)
					self.assertEqual(list(x.values()	)      ,       [30]	)
					self.assertEqual(list(x.items()	)      ,       [('a', 30)]	)
					self.assertEqual(list(SCREAMING_SNAKE_CASE	)      ,       ['a']	)

					SCREAMING_SNAKE_CASE_						:List[Any]										=      ModelOutputTest(a=30      ,       b=10	)
					self.assertEqual(list(x.keys()	)      ,       ['a', 'b']	)
					self.assertEqual(list(x.values()	)      ,       [30, 10]	)
					self.assertEqual(list(x.items()	)      ,       [('a', 30), ('b', 10)]	)
					self.assertEqual(list(SCREAMING_SNAKE_CASE	)      ,       ['a', 'b']	)

					SCREAMING_SNAKE_CASE_						:Tuple										=      ModelOutputTest(a=30      ,       c=10	)
					self.assertEqual(list(x.keys()	)      ,       ['a', 'c']	)
					self.assertEqual(list(x.values()	)      ,       [30, 10]	)
					self.assertEqual(list(x.items()	)      ,       [('a', 30), ('c', 10)]	)
					self.assertEqual(list(SCREAMING_SNAKE_CASE	)      ,       ['a', 'c']	)

					with self.assertRaises(SCREAMING_SNAKE_CASE	):
							SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      x.update({'d': 20}	)
					with self.assertRaises(SCREAMING_SNAKE_CASE	):
							del x["a"]
					with self.assertRaises(SCREAMING_SNAKE_CASE	):
							SCREAMING_SNAKE_CASE_						:str										=      x.pop('a'	)
					with self.assertRaises(SCREAMING_SNAKE_CASE	):
							SCREAMING_SNAKE_CASE_						:str										=      x.setdefault('d'      ,       32	)






			def 				_lowercase	(   self  :							Tuple	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Optional[Any]										=      ModelOutputTest(a=30	)
					SCREAMING_SNAKE_CASE_						:Optional[int]										=      10
					self.assertEqual(x.a      ,       10	)
					self.assertEqual(x['a']      ,       10	)






			def 				_lowercase	(   self  :							List[Any]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Dict										=      ModelOutputTest(a=30	)
					SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      10
					self.assertEqual(x.a      ,       10	)
					self.assertEqual(x['a']      ,       10	)






			def 				_lowercase	(   self  :							Optional[Any]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:int										=      ModelOutputTest({'a': 30, 'b': 10}	)
					self.assertEqual(list(x.keys()	)      ,       ['a', 'b']	)
					self.assertEqual(x.a      ,       30	)
					self.assertEqual(x.b      ,       10	)






			def 				_lowercase	(   self  :							Tuple	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Tuple										=      ModelOutputTest([('a', 30), ('b', 10)]	)
					self.assertEqual(list(x.keys()	)      ,       ['a', 'b']	)
					self.assertEqual(x.a      ,       30	)
					self.assertEqual(x.b      ,       10	)

					with self.assertRaises(SCREAMING_SNAKE_CASE	):
							SCREAMING_SNAKE_CASE_						:List[str]										=      ModelOutputTest([('a', 30), (10, 10)]	)

					SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      ModelOutputTest(a=(30, 30)	)
					self.assertEqual(list(x.keys()	)      ,       ['a']	)
					self.assertEqual(x.a      ,       (30, 30)	)





'''simple docstring'''







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE     ):
		for i, _ in enumerate(SCREAMING_SNAKE_CASE     ):
				if (i % 2 == 1) == (nums[i - 1] > nums[i]):
						SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_						:Dict										=      nums[i], nums[i - 1]

		return nums


if __name__ == "__main__":
							print("""Enter the array elements:""")
							SCREAMING_SNAKE_CASE__     : Tuple				=   list(map(int, input().split()))
							print("""The unsorted array is:""")
							print(array)
							print("""Array after Wiggle sort:""")
							print(wiggle_sort(array))
