



UpperCAmelCase :				Optional[int]							=[chr(i) for i in range(32, 126)]
UpperCAmelCase :				Union[str, Any]							=list(range(len(alphabets)))
UpperCAmelCase :				Optional[Any]							=list(range(len(alphabets)))
UpperCAmelCase :				Optional[Any]							=list(range(len(alphabets)))
UpperCAmelCase :				Dict							=list(reversed(range(len(alphabets))))
UpperCAmelCase :				Optional[Any]							=[]
UpperCAmelCase :				str							=0



def  _lowerCAmelCase     ():
					global gear_one_pos
					global gear_two_pos
					global gear_three_pos
					UpperCamelCase_			= gear_one[0]
					gear_one.append(_lowerCAmelCase)
					del gear_one[0]
					gear_one_pos += 1
					if gear_one_pos % int(len(_lowerCAmelCase)) == 0:
										UpperCamelCase_			= gear_two[0]
										gear_two.append(_lowerCAmelCase)
										del gear_two[0]
										gear_two_pos += 1
										if gear_two_pos % int(len(_lowerCAmelCase)) == 0:
															UpperCamelCase_			= gear_three[0]
															gear_three.append(_lowerCAmelCase)
															del gear_three[0]
															gear_three_pos += 1



def  _lowerCAmelCase     (_lowerCAmelCase):
					UpperCamelCase_			= alphabets.index(_lowerCAmelCase)
					UpperCamelCase_			= gear_one[target]
					UpperCamelCase_			= gear_two[target]
					UpperCamelCase_			= gear_three[target]
					UpperCamelCase_			= reflector[target]
					UpperCamelCase_			= gear_three.index(_lowerCAmelCase)
					UpperCamelCase_			= gear_two.index(_lowerCAmelCase)
					UpperCamelCase_			= gear_one.index(_lowerCAmelCase)
					code.append(alphabets[target])
					rotator()


if __name__ == "__main__":
	UpperCAmelCase :				Optional[Any]							=list(input("""Type your message:\n"""))
	while True:
		try:
			UpperCAmelCase :				Union[str, 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!"""
	)


def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: Union[str, Any]       ,				SCREAMING_SNAKE_CASE			: Any     )	->		Tuple:
				# "Simpson Rule"
				# int(f) = delta_x/2 * (b-a)/3*(f1 + 4f2 + 2f_3 + ... + fn)
				__lowercase								=   (boundary[1] - boundary[0]) / steps
				__lowercase								=   boundary[0]
				__lowercase								=   boundary[1]
				__lowercase								=   make_points(SCREAMING_SNAKE_CASE       ,				SCREAMING_SNAKE_CASE       ,				SCREAMING_SNAKE_CASE     )
				__lowercase								=   0.0
				y += (h / 3.0) * f(SCREAMING_SNAKE_CASE     )
				__lowercase								=   2
				for i in x_i:
								y += (h / 3) * (4 - 2 * (cnt % 2)) * f(SCREAMING_SNAKE_CASE     )
								cnt += 1
				y += (h / 3.0) * f(SCREAMING_SNAKE_CASE     )
				return y




def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: List[Any]       ,				SCREAMING_SNAKE_CASE			: Dict       ,				SCREAMING_SNAKE_CASE			: int     )	->		Any:
				__lowercase								=   a + h
				while x < (b - h):
								yield x
								__lowercase								=   x + h




def 				__SCREAMING_SNAKE_CASE  (						SCREAMING_SNAKE_CASE			: Any     )	->		List[Any]:  # enter your function here
				__lowercase								=   (x - 0) * (x - 0)
				return y




def 				__SCREAMING_SNAKE_CASE  (						)	->		List[str]:
				__lowercase								=   0.0  # Lower bound of integration
				__lowercase								=   1.0  # Upper bound of integration
				__lowercase								=   10.0  # define number of steps or resolution
				__lowercase								=   [a, b]  # define boundary of integration
				__lowercase								=   method_a(SCREAMING_SNAKE_CASE       ,				SCREAMING_SNAKE_CASE     )
				print(F"""y = {y}"""     )


if __name__ == "__main__":
							main()





