



'''simple docstring'''




UpperCamelCase__	:     str		  =			[chr(i) for i in range(32, 1_26)]
UpperCamelCase__	:     Tuple		  =			list(range(len(alphabets)))
UpperCamelCase__	:     Dict		  =			list(range(len(alphabets)))
UpperCamelCase__	:     List[Any]		  =			list(range(len(alphabets)))
UpperCamelCase__	:     List[Any]		  =			list(reversed(range(len(alphabets))))
UpperCamelCase__	:     Optional[int]		  =			[]
UpperCamelCase__	:     Any		  =			0


def     lowerCAmelCase_       (     ):
		global gear_one_pos
		global gear_two_pos
		global gear_three_pos
		__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		gear_one[0]
		gear_one.append(_lowerCamelCase )
		del gear_one[0]
		gear_one_pos += 1
		if gear_one_pos % int(len(_lowerCamelCase ) ) == 0:
				__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		gear_two[0]
				gear_two.append(_lowerCamelCase )
				del gear_two[0]
				gear_two_pos += 1
				if gear_two_pos % int(len(_lowerCamelCase ) ) == 0:
						__SCREAMING_SNAKE_CASE	:		Dict   	=		gear_three[0]
						gear_three.append(_lowerCamelCase )
						del gear_three[0]
						gear_three_pos += 1


def     lowerCAmelCase_       (     _lowerCamelCase:       List[Any] ):
		__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		alphabets.index(_lowerCamelCase )
		__SCREAMING_SNAKE_CASE	:		Any   	=		gear_one[target]
		__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		gear_two[target]
		__SCREAMING_SNAKE_CASE	:		List[str]   	=		gear_three[target]
		__SCREAMING_SNAKE_CASE	:		List[str]   	=		reflector[target]
		__SCREAMING_SNAKE_CASE	:		Dict   	=		gear_three.index(_lowerCamelCase )
		__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		gear_two.index(_lowerCamelCase )
		__SCREAMING_SNAKE_CASE	:		List[str]   	=		gear_one.index(_lowerCamelCase )
		code.append(alphabets[target] )
		rotator()


if __name__ == "__main__":
						UpperCamelCase__	:     List[str]		  =			list(input('''Type your message:\n'''))
						while True:
												try:
																		UpperCamelCase__	:     Any		  =			int(input('''Please set token:(must be only digits)\n'''))
																		break
												except Exception as error:
																		print(error)
						for _ in range(token):
												rotator()
						for j in decode:
												engine(j)
						print('''\n''' + ''''''.join(code))
						print(
						    f"\nYour Token is {token} please write it down.\nIf you want to decode "
						    '''this message again you should input same digits as token!'''
						)




'''simple docstring'''




UpperCamelCase__	:     List[Any]    =			10_00


def     lowerCAmelCase_       (     _lowerCamelCase:       float ):
		return x * x


def     lowerCAmelCase_       (     _lowerCamelCase:       Any	,				_lowerCamelCase:       float	,				_lowerCamelCase:       float	,				_lowerCamelCase:       int = 4 ):
		assert callable(
		    _lowerCamelCase ), F"the function(object) passed should be callable your input : {function}"
		assert isinstance(_lowerCamelCase	,				(float, int) ), F"a should be float or integer your input : {a}"
		assert isinstance(function(_lowerCamelCase )	,				(float, int) ), (
		    "the function should return integer or float return type of your function, "
		    F"{type(_lowerCamelCase )}"
		)
		assert isinstance(_lowerCamelCase	,				(float, int) ), F"b should be float or integer your input : {b}"
		assert (
		    isinstance(_lowerCamelCase	,				_lowerCamelCase ) and precision > 0
		), F"precision should be positive integer your input : {precision}"

		# just applying the formula of simpson for approximate integration written in
		# mentioned article in first comment of this file and above this function

		__SCREAMING_SNAKE_CASE	:		List[Any]   	=		(b - a) / N_STEPS
		__SCREAMING_SNAKE_CASE	:		List[Any]   	=		function(_lowerCamelCase ) + function(_lowerCamelCase )

		for i in range(1	,				_lowerCamelCase ):
				__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		a + h * i
				result += function(_lowerCamelCase ) * (4 if i % 2 else 2)

		result *= h / 3
		return round(_lowerCamelCase	,				_lowerCamelCase )


if __name__ == "__main__":
						import doctest

						doctest.testmod()