




from manim import *




class     A					(				lowerCamelCase_       ):







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

										"""simple docstring"""



										UpperCamelCase_     				= Rectangle(height=0.5   ,     width=0.5				)
										UpperCamelCase_     				= Rectangle(height=0.46   ,     width=0.46				).set_stroke(width=0				)
										UpperCamelCase_     				= Rectangle(height=0.25   ,     width=0.25				)

										UpperCamelCase_     				= [mem.copy() for i in range(6				)]
										UpperCamelCase_     				= [mem.copy() for i in range(6				)]
										UpperCamelCase_     				= VGroup(*__UpperCAmelCase				).arrange(__UpperCAmelCase   ,     buff=0				)
										UpperCamelCase_     				= VGroup(*__UpperCAmelCase				).arrange(__UpperCAmelCase   ,     buff=0				)
										UpperCamelCase_     				= VGroup(__UpperCAmelCase   ,     __UpperCAmelCase				).arrange(__UpperCAmelCase   ,     buff=0				)
										UpperCamelCase_     				= Text('CPU'   ,     font_size=24				)
										UpperCamelCase_     				= Group(__UpperCAmelCase   ,     __UpperCAmelCase				).arrange(__UpperCAmelCase   ,     buff=0.5   ,     aligned_edge=__UpperCAmelCase				)
										cpu.move_to([-2.5, -0.5, 0]				)
										self.add(__UpperCAmelCase				)

										UpperCamelCase_     				= [mem.copy() for i in range(4				)]
										UpperCamelCase_     				= VGroup(*__UpperCAmelCase				).arrange(__UpperCAmelCase   ,     buff=0				)
										UpperCamelCase_     				= Text('GPU'   ,     font_size=24				)
										UpperCamelCase_     				= Group(__UpperCAmelCase   ,     __UpperCAmelCase				).arrange(__UpperCAmelCase   ,     buff=0.5   ,     aligned_edge=__UpperCAmelCase				)
										gpu.move_to([-1, -1, 0]				)
										self.add(__UpperCAmelCase				)

										UpperCamelCase_     				= [mem.copy() for i in range(6				)]
										UpperCamelCase_     				= VGroup(*__UpperCAmelCase				).arrange(__UpperCAmelCase   ,     buff=0				)

										UpperCamelCase_     				= Text('Model'   ,     font_size=24				)
										UpperCamelCase_     				= Group(__UpperCAmelCase   ,     __UpperCAmelCase				).arrange(__UpperCAmelCase   ,     buff=0.5   ,     aligned_edge=__UpperCAmelCase				)
										model.move_to([3, -1.0, 0]				)
										self.add(__UpperCAmelCase				)

										UpperCamelCase_     				= []
										UpperCamelCase_     				= []

										for i, rect in enumerate(__UpperCAmelCase				):
													rect.set_stroke(__UpperCAmelCase				)

													UpperCamelCase_     				= Rectangle(height=0.46 / 4   ,     width=0.46 / 3				).set_stroke(width=0.0				).set_fill(__UpperCAmelCase   ,     opacity=0.7				)

													if i == 0:
																cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT				)   ,     buff=0.02   ,     direction=__UpperCAmelCase				)
																cpu_target.set_x(cpu_target.get_x() + 0.1				)
													elif i == 3:
																cpu_target.next_to(model_cpu_arr[0]   ,     direction=__UpperCAmelCase   ,     buff=0.0				)
													else:
																cpu_target.next_to(model_cpu_arr[i - 1]   ,     direction=__UpperCAmelCase   ,     buff=0.0				)
													self.add(__UpperCAmelCase				)
													model_cpu_arr.append(__UpperCAmelCase				)

										self.add(*__UpperCAmelCase   ,     *__UpperCAmelCase				)

										UpperCamelCase_     				= [meta_mem.copy() for i in range(6				)]
										UpperCamelCase_     				= [meta_mem.copy() for i in range(6				)]
										UpperCamelCase_     				= VGroup(*__UpperCAmelCase				).arrange(__UpperCAmelCase   ,     buff=0				)
										UpperCamelCase_     				= VGroup(*__UpperCAmelCase				).arrange(__UpperCAmelCase   ,     buff=0				)
										UpperCamelCase_     				= VGroup(__UpperCAmelCase   ,     __UpperCAmelCase				).arrange(__UpperCAmelCase   ,     buff=0				)
										UpperCamelCase_     				= Text('Disk'   ,     font_size=24				)
										UpperCamelCase_     				= Group(__UpperCAmelCase   ,     __UpperCAmelCase				).arrange(__UpperCAmelCase   ,     buff=0.5   ,     aligned_edge=__UpperCAmelCase				)
										disk.move_to([-4.0, -1.25, 0]				)
										self.add(__UpperCAmelCase   ,     __UpperCAmelCase				)

										UpperCamelCase_     				= []

										for i in range(6				):
													UpperCamelCase_     				= fill.copy().set_fill(__UpperCAmelCase   ,     opacity=0.8				)
													target.move_to(disk_left_col_base[i]				).scale(0.5				)
													cpu_disk_arr.append(__UpperCAmelCase				)

										self.add(*__UpperCAmelCase				)

										UpperCamelCase_     				= Square(side_length=2.2				)
										key.move_to([-5, 2, 0]				)

										UpperCamelCase_     				= MarkupText(
										    f'''<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model'''   ,     font_size=18   ,     )

										key_text.move_to([-5, 2.4, 0]				)

										self.add(__UpperCAmelCase   ,     __UpperCAmelCase				)

										UpperCamelCase_     				= MarkupText(
										    f'''<span fgcolor=\'{BLUE}\'>●</span> Checkpoint'''   ,     font_size=18   ,     )

										blue_text.next_to(__UpperCAmelCase   ,     DOWN * 2.4   ,     aligned_edge=key_text.get_left()				)
										self.add(__UpperCAmelCase				)

										UpperCamelCase_     				= MarkupText(f'''The offloaded weights are all sent to the CPU.'''   ,     font_size=24				)
										step_a.move_to([2, 2, 0]				)

										self.play(Write(__UpperCAmelCase   ,     run_time=3				)				)

										for i in range(6				):
													UpperCamelCase_     				= cpu_disk_arr[i]
													UpperCamelCase_     				= rect.copy().set_fill(__UpperCAmelCase   ,     opacity=0.8				).scale(2.0				)
													cpa.generate_target()
													cpa.target.move_to(model_base[i]				)

													if i == 0:
																rect.set_fill(__UpperCAmelCase   ,     opacity=0.8				)
																rect.generate_target()
																rect.target.move_to(cpu_left_col_base[0]				).scale(2.0				)

																self.remove(
																    *__UpperCAmelCase   ,     *__UpperCAmelCase   ,     )

													else:
																rect.generate_target()
																rect.target.move_to(cpu_left_col_base[i]				).scale(2.0				)
													self.play(MoveToTarget(__UpperCAmelCase				)   ,     MoveToTarget(__UpperCAmelCase				)   ,     model_base[i].animate.set_stroke(__UpperCAmelCase				)				)
										self.play(FadeOut(__UpperCAmelCase				)				)

										UpperCamelCase_     				= MarkupText(
										    f'''Finally, hooks are added to each weight in the model\nto transfer the weights from CPU to GPU\n\t\tand back when needed.'''   ,     font_size=24   ,     )
										step_a.move_to([2, 2, 0]				)

										self.play(Write(__UpperCAmelCase   ,     run_time=3				)				)

										UpperCamelCase_     				= []
										UpperCamelCase_     				= []
										for i in range(6				):
													UpperCamelCase_     				= Arrow(start=__UpperCAmelCase   ,     end=__UpperCAmelCase   ,     color=__UpperCAmelCase   ,     buff=0.5				)
													a.next_to(model_base[i].get_left()   ,     __UpperCAmelCase   ,     buff=0.2				)
													arrows.append(__UpperCAmelCase				)
													animations.append(Write(__UpperCAmelCase				)				)
										self.play(*__UpperCAmelCase				)
										self.wait()






__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!"""
				)
