




from __future__ import annotations

import random
import string




class     A					:







							def __init__(    self   :	Optional[Any]   ,     __UpperCAmelCase   :	str | None = None				)		->					None:

										"""simple docstring"""



										UpperCamelCase_     				= passcode or self.__passcode_creator()
										UpperCamelCase_     				= self.__make_key_list()
										UpperCamelCase_     				= self.__make_shift_key()







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

										"""simple docstring"""



										return "".join(self.__passcode				)







							def        lowercase__							(    self   :	int   ,     __UpperCAmelCase   :	list[int]				)		->					list[int]:

										"""simple docstring"""



										for i in range(1   ,     len(__UpperCAmelCase				)   ,     2				):
													iterlist[i] *= -1
										return iterlist







							def        lowercase__							(    self   :	int				)		->					list[str]:

										"""simple docstring"""



										UpperCamelCase_     				= string.ascii_letters + string.digits
										UpperCamelCase_     				= [random.choice(__UpperCAmelCase				) for _ in range(random.randint(10   ,     20				)				)]
										return password







							def        lowercase__							(    self   :	Tuple				)		->					list[str]:

										"""simple docstring"""



										UpperCamelCase_     				= (
										    string.ascii_letters + string.digits + string.punctuation + ' \t\n'
										)

										UpperCamelCase_     				= []

										# creates points known as breakpoints to break the key_list_options at those
										# points and pivot each substring
										UpperCamelCase_     				= sorted(set(self.__passcode				)				)
										UpperCamelCase_     				= []

										# algorithm for creating a new shuffled list, keys_l, out of key_list_options
										for i in key_list_options:
													temp_list.extend(__UpperCAmelCase				)

													# checking breakpoints at which to pivot temporary sublist and add it into
													# keys_l
													if i in breakpoints or i == key_list_options[-1]:
																keys_l.extend(temp_list[::-1]				)
																temp_list.clear()

        # returning a shuffled keys_l to prevent brute force guessing of shift key
										return keys_l







							def        lowercase__							(    self   :	List[str]				)		->					int:

										"""simple docstring"""



										UpperCamelCase_     				= sum(self.__neg_pos([ord(__UpperCAmelCase				) for x in self.__passcode]				)				)
										return num if num > 0 else len(self.__passcode				)







							def        lowercase__							(    self   :	int   ,     __UpperCAmelCase   :	str				)		->					str:

										"""simple docstring"""



										UpperCamelCase_     				= ''

										# decoding shift like Caesar cipher algorithm implementing negative shift or
										# reverse shift or left shift
										for i in encoded_message:
													UpperCamelCase_     				= self.__key_list.index(__UpperCAmelCase				)
													decoded_message += self.__key_list[
													    (position - self.__shift_key) % -len(self.__key_list				)
													]

										return decoded_message







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

										"""simple docstring"""



										UpperCamelCase_     				= ''

										# encoding shift like Caesar cipher algorithm implementing positive shift or
										# forward shift or right shift
										for i in plaintext:
													UpperCamelCase_     				= self.__key_list.index(__UpperCAmelCase				)
													encoded_message += self.__key_list[
													    (position + self.__shift_key) % len(self.__key_list				)
													]

										return encoded_message







def  a_		(							__snake_case = "Hello, this is a modified Caesar cipher"					)	->			str:

			'''simple docstring'''


			UpperCamelCase_     				= ShuffledShiftCipher()
			return cipa.decrypt(cipa.encrypt(__snake_case					)					)


if __name__ == "__main__":
				import doctest

				doctest.testmod()






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




def  a_		(							)	->			Dict:

			'''simple docstring'''


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




def  a_		(							__snake_case					)	->			Any:

			'''simple docstring'''


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


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