



import sys

sys.set_int_max_str_digits(0)  # type: ignore


def       UpperCamelCase(  __UpperCamelCase							:		int			):
		lowerCAmelCase_      :					Any     =			[0] * 11
		lowerCAmelCase_      :					Optional[int]     =			[0] * 11

		# mark last 9 numbers
		for _ in range(9			):
				lowerCAmelCase_      :					List[Any]     =			1
				lowerCAmelCase_      :					Optional[int]     =			number // 10
		# flag
		lowerCAmelCase_      :					Any     =			True

		# check last 9 numbers for pandigitality

		for x in range(9			):
				if not check_last[x + 1]:
						lowerCAmelCase_      :					str     =			False
		if not f:
				return f

		# mark first 9 numbers
		lowerCAmelCase_      :					List[str]     =			int(str(__UpperCamelCase			)[:9]			)

		for _ in range(9			):
				lowerCAmelCase_      :					Union[str, Any]     =			1
				lowerCAmelCase_      :					int     =			number // 10

		# check first 9 numbers for pandigitality

		for x in range(9			):
				if not check_front[x + 1]:
						lowerCAmelCase_      :					List[str]     =			False
		return f


def       UpperCamelCase(  __UpperCamelCase							:		int			):
		lowerCAmelCase_      :					Optional[int]     =			[0] * 11

		# mark last 9 numbers
		for _ in range(9			):
				lowerCAmelCase_      :					str     =			1
				lowerCAmelCase_      :					List[str]     =			number // 10
		# flag
		lowerCAmelCase_      :					Any     =			True

		# check last 9 numbers for pandigitality

		for x in range(9			):
				if not check_last[x + 1]:
						lowerCAmelCase_      :					Any     =			False
		return f


def       UpperCamelCase(  ):
		lowerCAmelCase_      :					Union[str, Any]     =			1
		lowerCAmelCase_      :					Optional[int]     =			1
		lowerCAmelCase_      :					str     =			2
		# temporary Fibonacci numbers

		lowerCAmelCase_      :					Optional[Any]     =			1
		lowerCAmelCase_      :					Dict     =			1
		lowerCAmelCase_      :					List[Any]     =			2
		# temporary Fibonacci numbers mod 1e9

		# mod m=1e9, done for fast optimisation
		lowerCAmelCase_      :					List[str]     =			[0] * 1000000
		lowerCAmelCase_      :					str     =			1000000000

		for x in range(1000000			):
				lowerCAmelCase_      :					Optional[Any]     =			(aa + ba) % m
				lowerCAmelCase_      :					Dict     =			ba % m
				lowerCAmelCase_      :					List[Any]     =			ca % m
				if checka(__UpperCamelCase			):
						lowerCAmelCase_      :					Any     =			1

		for x in range(1000000			):
				lowerCAmelCase_      :					List[Any]     =			a + b
				lowerCAmelCase_      :					Optional[Any]     =			b
				lowerCAmelCase_      :					Tuple     =			c
				# perform check only if in tocheck
				if tocheck[x + 3] and check(__UpperCamelCase			):
						return x + 3  # first 2 already done
		return -1


if __name__ == "__main__":
						print(F'''{solution() = }''')










def       UpperCamelCase(  __UpperCamelCase							:		list			):
		for i, _ in enumerate(__UpperCamelCase			):
				if (i % 2 == 1) == (nums[i - 1] > nums[i]):
						lowerCAmelCase_ ,  lowerCAmelCase_      :					Union[str, Any]     =			nums[i], nums[i - 1]

		return nums


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





