





from manim import *


class   A			(SCREAMING_SNAKE_CASE    ):
			'''simple docstring'''




			def    a_       (			self   :    str   )	->	Any:







					"""simple docstring"""






					A__        =   Rectangle(height=0.5							,	width=0.5   )
					A__        =   Rectangle(height=0.4_6							,	width=0.4_6   ).set_stroke(width=0   )

					A__        =   Rectangle(height=0.2_5							,	width=0.2_5   )

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

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

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

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

					A__        =   []
					A__        =   []

					for i, rect in enumerate(__lowerCAmelCase   ):
							A__        =   fill.copy().set_fill(__lowerCAmelCase							,	opacity=0.8   )
							target.move_to(__lowerCAmelCase   )
							model_arr.append(__lowerCAmelCase   )

							A__        =   Rectangle(height=0.4_6							,	width=0.4_6   ).set_stroke(width=0.0   ).set_fill(__lowerCAmelCase							,	opacity=0.8   )
							cpu_target.move_to(cpu_left_col_base[i]   )
							model_cpu_arr.append(__lowerCAmelCase   )

					self.add(*__lowerCAmelCase							,	*__lowerCAmelCase   )

					A__        =   [meta_mem.copy() for i in range(6   )]
					A__        =   [meta_mem.copy() for i in range(6   )]
					A__        =   VGroup(*__lowerCAmelCase   ).arrange(__lowerCAmelCase							,	buff=0   )
					A__        =   VGroup(*__lowerCAmelCase   ).arrange(__lowerCAmelCase							,	buff=0   )
					A__        =   VGroup(__lowerCAmelCase							,	__lowerCAmelCase   ).arrange(__lowerCAmelCase							,	buff=0   )
					A__        =   Text("""Disk"""							,	font_size=24   )
					A__        =   Group(__lowerCAmelCase							,	__lowerCAmelCase   ).arrange(__lowerCAmelCase							,	buff=0.5							,	aligned_edge=__lowerCAmelCase   )
					disk.move_to([-4, -1.2_5, 0]   )
					self.add(__lowerCAmelCase							,	__lowerCAmelCase   )

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

					A__        =   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(__lowerCAmelCase							,	__lowerCAmelCase   )

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

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

					A__        =   MarkupText(
					    f'Now watch as an input is passed through the model\nand how the memory is utilized and handled.'							,	font_size=24							,	)
					step_a.move_to([2, 2, 0]   )

					self.play(Write(__lowerCAmelCase   )   )

					A__        =   Square(0.3   )
					input.set_fill(__lowerCAmelCase							,	opacity=1.0   )
					input.set_stroke(width=0.0   )
					input.next_to(model_base[0]							,	__lowerCAmelCase							,	buff=0.5   )

					self.play(Write(__lowerCAmelCase   )   )

					input.generate_target()
					input.target.next_to(model_arr[0]							,	direction=__lowerCAmelCase							,	buff=0.0_2   )
					self.play(MoveToTarget(__lowerCAmelCase   )   )

					self.play(FadeOut(__lowerCAmelCase   )   )

					A__        =   Arrow(start=__lowerCAmelCase							,	end=__lowerCAmelCase							,	color=__lowerCAmelCase							,	buff=0.5   )
					a.next_to(model_arr[0].get_left()							,	__lowerCAmelCase							,	buff=0.2   )

					model_cpu_arr[0].generate_target()
					model_cpu_arr[0].target.move_to(gpu_rect[0]   )

					A__        =   MarkupText(
					    f'As the input reaches a layer, the hook triggers\nand weights are moved from the CPU\nto the GPU and back.'							,	font_size=24							,	)
					step_a.move_to([2, 2, 0]   )

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

					A__        =   {"""run_time""": 1, """fade_in""": True, """fade_out""": True, """buff""": 0.0_2}

					self.play(
					    Write(__lowerCAmelCase   )							,	Circumscribe(model_arr[0]							,	color=__lowerCAmelCase							,	**__lowerCAmelCase   )							,	Circumscribe(model_cpu_arr[0]							,	color=__lowerCAmelCase							,	**__lowerCAmelCase   )							,	Circumscribe(gpu_rect[0]							,	color=__lowerCAmelCase							,	**__lowerCAmelCase   )							,	)
					self.play(MoveToTarget(model_cpu_arr[0]   )   )

					A__        =   a.copy()
					for i in range(6   ):
							a_c.next_to(model_arr[i].get_right() + 0.0_2							,	__lowerCAmelCase							,	buff=0.2   )

							input.generate_target()
							input.target.move_to(model_arr[i].get_right() + 0.0_2   )

							A__        =   AnimationGroup(
							    FadeOut(__lowerCAmelCase							,	run_time=0.5   )							,	MoveToTarget(__lowerCAmelCase							,	run_time=0.5   )							,	FadeIn(__lowerCAmelCase							,	run_time=0.5   )							,	lag_ratio=0.2   )

							self.play(__lowerCAmelCase   )

							model_cpu_arr[i].generate_target()
							model_cpu_arr[i].target.move_to(cpu_left_col_base[i]   )

							if i < 5:
									model_cpu_arr[i + 1].generate_target()
									model_cpu_arr[i + 1].target.move_to(gpu_rect[0]   )
									if i >= 1:
											A__        =   0.7

									self.play(
									    Circumscribe(model_arr[i]							,	**__lowerCAmelCase   )							,	Circumscribe(cpu_left_col_base[i]							,	**__lowerCAmelCase   )							,	Circumscribe(cpu_left_col_base[i + 1]							,	color=__lowerCAmelCase							,	**__lowerCAmelCase   )							,	Circumscribe(gpu_rect[0]							,	color=__lowerCAmelCase							,	**__lowerCAmelCase   )							,	Circumscribe(model_arr[i + 1]							,	color=__lowerCAmelCase							,	**__lowerCAmelCase   )							,	)
									if i < 1:
											self.play(
											    MoveToTarget(model_cpu_arr[i]   )							,	MoveToTarget(model_cpu_arr[i + 1]   )							,	)
									else:
											self.play(
											    MoveToTarget(model_cpu_arr[i]							,	run_time=0.7   )							,	MoveToTarget(model_cpu_arr[i + 1]							,	run_time=0.7   )							,	)
							else:
									model_cpu_arr[i].generate_target()
									model_cpu_arr[i].target.move_to(cpu_left_col_base[-1]   )
									input.generate_target()
									input.target.next_to(model_arr[-1].get_right()							,	RIGHT + 0.0_2							,	buff=0.2   )

									self.play(
									    Circumscribe(model_arr[-1]							,	color=__lowerCAmelCase							,	**__lowerCAmelCase   )							,	Circumscribe(cpu_left_col_base[-1]							,	color=__lowerCAmelCase							,	**__lowerCAmelCase   )							,	Circumscribe(gpu_rect[0]							,	color=__lowerCAmelCase							,	**__lowerCAmelCase   )							,	)

									self.play(MoveToTarget(model_cpu_arr[i]   )   )

							A__        =   a_c
							A__        =   a_c.copy()

					input.generate_target()
					input.target.next_to(model_base[-1]							,	RIGHT + 0.0_2							,	buff=0.5   )
					self.play(
					    FadeOut(__lowerCAmelCase   )							,	FadeOut(__lowerCAmelCase							,	run_time=0.5   )							,	)

					A__        =   MarkupText(f'Inference on a model too large for GPU memory\nis successfully completed.'							,	font_size=24   )
					step_a.move_to([2, 2, 0]   )

					self.play(Write(__lowerCAmelCase							,	run_time=3   )							,	MoveToTarget(__lowerCAmelCase   )   )

					self.wait()










from math import ceil







def    __lowerCamelCase					(							__a   :int = 1_0_0_1    )		->				int:






		"""simple docstring"""

		A__        =   1

		for i in range(1    ,     int(ceil(n / 2.0    )    )    ):
				A__        =   2 * i + 1
				A__        =   2 * i
				A__        =   total + 4 * odd**2 - 6 * even

		return total


if __name__ == "__main__":
					import sys

					if len(sys.argv) == 1:
										print(solution())
					else:
										try:
															A    :					List[str] =      int(sys.argv[1])
															print(solution(n))
										except ValueError:
															print('''Invalid entry - please enter a number''')



