




'''simple docstring'''





from manim import *




class  _snake_case		(	lowercase_							):




			def    lowerCAmelCase__				(					self							)				->				str:

										'''simple docstring'''




										snake_case_						=      Rectangle(height=0.5				,							width=0.5							)
										snake_case_						=      Rectangle(height=0.2_5				,							width=0.2_5							)
										snake_case_						=      Rectangle(height=0.4_6				,							width=0.4_6							).set_stroke(width=0							)

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

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

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

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

										snake_case_						=      []
										snake_case_						=      []
										snake_case_						=      []

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

																	snake_case_						=      Rectangle(height=0.4_6 / 4				,							width=0.4_6 / 3							).set_stroke(width=0.0							).set_fill(a__				,							opacity=0.7							)

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

										self.add(*a__				,							*a__				,							*a__							)

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

										snake_case_						=      Text("Loaded Checkpoint"				,							font_size=24							)
										snake_case_						=      Group(a__				,							a__							).arrange(a__				,							buff=0.5				,							aligned_edge=a__							)
										checkpoint.move_to([3, 0.5, 0]							)

										self.add(a__							)

										snake_case_						=      []
										snake_case_						=      []

										for i, rect in enumerate(a__							):
																	snake_case_						=      fill.copy().set_fill(a__				,							opacity=0.7							)
																	target.move_to(a__							)
																	ckpt_arr.append(a__							)

																	snake_case_						=      target.copy()
																	if i < 5:
																								cpu_target.move_to(cpu_left_col_base[i + 1]							)
																	else:
																								cpu_target.move_to(cpu_right_col_base[i - 5]							)
																	ckpt_cpu_arr.append(a__							)
										self.add(*a__				,							*a__							)

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

										snake_case_						=      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(a__				,							a__							)

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

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

										snake_case_						=      MarkupText(
										    F'Based on the passed in configuration, weights are stored in\na variety of np.memmaps on disk or to a particular device.'				,							font_size=24				,							)
										step_a.move_to([2, 2, 0]							)

										snake_case_						=      [meta_mem.copy() for i in range(6							)]
										snake_case_						=      [meta_mem.copy() for i in range(6							)]
										snake_case_						=      VGroup(*a__							).arrange(a__				,							buff=0							)
										snake_case_						=      VGroup(*a__							).arrange(a__				,							buff=0							)
										snake_case_						=      VGroup(a__				,							a__							).arrange(a__				,							buff=0							)
										snake_case_						=      Text("Disk"				,							font_size=24							)
										snake_case_						=      Group(a__				,							a__							).arrange(a__				,							buff=0.5				,							aligned_edge=a__							)
										disk.move_to([-4.0, -1.2_5, 0]							)
										self.play(Write(a__				,							run_time=3							)				,							Write(a__				,							run_time=1							)				,							Create(a__				,							run_time=1							)							)

										snake_case_						=      []
										for i, rect in enumerate(a__							):
																	snake_case_						=      rect.copy()
																	target.generate_target()
																	target.target.move_to(disk_left_col_base[i]							).scale(0.5							)
																	animations.append(MoveToTarget(a__				,							run_time=1.5							)							)
										self.play(*a__							)

										self.play(FadeOut(a__							)							)

										snake_case_						=      MarkupText(F'Then, the checkpoint is removed from memory\nthrough garbage collection.'				,							font_size=24							)
										step_a.move_to([2, 2, 0]							)

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

										self.play(
										    FadeOut(a__				,							a__				,							*a__				,							*a__							)				,							)

										self.wait()









import string


def 			UpperCamelCase(  __UpperCamelCase							:		str ):
		for key in range(len(string.ascii_uppercase ) ):
				lowerCAmelCase_			:     List[Any]									= ''''''
				for symbol in message:
						if symbol in string.ascii_uppercase:
								lowerCAmelCase_			:     Optional[int]									= string.ascii_uppercase.find(__UpperCamelCase )
								lowerCAmelCase_			:     Optional[int]									= num - key
								if num < 0:
										lowerCAmelCase_			:     int									= num + len(string.ascii_uppercase )
								lowerCAmelCase_			:     int									= translated + string.ascii_uppercase[num]
						else:
								lowerCAmelCase_			:     Optional[int]									= translated + symbol
				print(f"""Decryption using Key #{key}: {translated}""" )


def 			UpperCamelCase(  ):
		lowerCAmelCase_			:     Dict									= input('''Encrypted message: ''' )
		lowerCAmelCase_			:     List[str]									= message.upper()
		decrypt(__UpperCamelCase )


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						main()





