from manim import *



class        lowercase_   (					__snake_case		):



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					Dict    =   Rectangle(height=0.5				,    width=0.5    )
													_snake_case						:					Dict    =   Rectangle(height=0.46				,    width=0.46    ).set_stroke(width=0    )

													_snake_case						:					Union[str, Any]    =   Rectangle(height=0.25				,    width=0.25    )

													_snake_case						:					int    =   [mem.copy() for i in range(6    )]
													_snake_case						:					str    =   [mem.copy() for i in range(6    )]
													_snake_case						:					str    =   VGroup(*lowercase_    ).arrange(lowercase_				,    buff=0    )
													_snake_case						:					Any    =   VGroup(*lowercase_    ).arrange(lowercase_				,    buff=0    )
													_snake_case						:					Any    =   VGroup(lowercase_				,    lowercase_    ).arrange(lowercase_				,    buff=0    )
													_snake_case						:					List[str]    =   Text("CPU"				,    font_size=24    )
													_snake_case						:					List[Any]    =   Group(lowercase_				,    lowercase_    ).arrange(lowercase_				,    buff=0.5				,    aligned_edge=lowercase_    )
													cpu.move_to([-2.5, -0.5, 0]    )
													self.add(lowercase_    )

													_snake_case						:					List[str]    =   [mem.copy() for i in range(4    )]
													_snake_case						:					Optional[int]    =   VGroup(*lowercase_    ).arrange(lowercase_				,    buff=0    )
													_snake_case						:					Optional[Any]    =   Text("GPU"				,    font_size=24    )
													_snake_case						:					Union[str, Any]    =   Group(lowercase_				,    lowercase_    ).arrange(lowercase_				,    buff=0.5				,    aligned_edge=lowercase_    )
													gpu.move_to([-1, -1, 0]    )
													self.add(lowercase_    )

													_snake_case						:					Dict    =   [mem.copy() for i in range(6    )]
													_snake_case						:					Any    =   VGroup(*lowercase_    ).arrange(lowercase_				,    buff=0    )

													_snake_case						:					Any    =   Text("Model"				,    font_size=24    )
													_snake_case						:					Optional[int]    =   Group(lowercase_				,    lowercase_    ).arrange(lowercase_				,    buff=0.5				,    aligned_edge=lowercase_    )
													model.move_to([3, -1.0, 0]    )
													self.add(lowercase_    )

													_snake_case						:					Union[str, Any]    =   []
													_snake_case						:					Dict    =   []

													for i, rect in enumerate(lowercase_    ):
																			_snake_case						:					List[str]    =   fill.copy().set_fill(lowercase_				,    opacity=0.8    )
																			target.move_to(lowercase_    )
																			model_arr.append(lowercase_    )

																			_snake_case						:					Optional[int]    =   Rectangle(height=0.46				,    width=0.46    ).set_stroke(width=0.0    ).set_fill(lowercase_				,    opacity=0.8    )
																			cpu_target.move_to(cpu_left_col_base[i]    )
																			model_cpu_arr.append(lowercase_    )

													self.add(*lowercase_				,    *lowercase_    )

													_snake_case						:					List[str]    =   [meta_mem.copy() for i in range(6    )]
													_snake_case						:					List[str]    =   [meta_mem.copy() for i in range(6    )]
													_snake_case						:					Any    =   VGroup(*lowercase_    ).arrange(lowercase_				,    buff=0    )
													_snake_case						:					str    =   VGroup(*lowercase_    ).arrange(lowercase_				,    buff=0    )
													_snake_case						:					Dict    =   VGroup(lowercase_				,    lowercase_    ).arrange(lowercase_				,    buff=0    )
													_snake_case						:					Dict    =   Text("Disk"				,    font_size=24    )
													_snake_case						:					Optional[int]    =   Group(lowercase_				,    lowercase_    ).arrange(lowercase_				,    buff=0.5				,    aligned_edge=lowercase_    )
													disk.move_to([-4, -1.25, 0]    )
													self.add(lowercase_				,    lowercase_    )

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

													_snake_case						:					int    =   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(lowercase_				,    lowercase_    )

													_snake_case						:					Dict    =   MarkupText(
													    f"""<span fgcolor='{BLUE}'>●</span> Checkpoint"""				,    font_size=18				,    )

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

													_snake_case						:					Tuple    =   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(lowercase_    )    )

													_snake_case						:					Dict    =   Square(0.3    )
													input.set_fill(lowercase_				,    opacity=1.0    )
													input.set_stroke(width=0.0    )
													input.next_to(model_base[0]				,    lowercase_				,    buff=0.5    )

													self.play(Write(lowercase_    )    )

													input.generate_target()
													input.target.next_to(model_arr[0]				,    direction=lowercase_				,    buff=0.02    )
													self.play(MoveToTarget(lowercase_    )    )

													self.play(FadeOut(lowercase_    )    )

													_snake_case						:					List[Any]    =   Arrow(start=lowercase_				,    end=lowercase_				,    color=lowercase_				,    buff=0.5    )
													a.next_to(model_arr[0].get_left()				,    lowercase_				,    buff=0.2    )

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

													_snake_case						:					Optional[Any]    =   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(lowercase_				,    run_time=3    )    )

													_snake_case						:					Dict    =   {"run_time": 1, "fade_in": True, "fade_out": True, "buff": 0.02}

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

													_snake_case						:					Optional[int]    =   a.copy()
													for i in range(6    ):
																			a_c.next_to(model_arr[i].get_right() + 0.02				,    lowercase_				,    buff=0.2    )

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

																			_snake_case						:					Any    =   AnimationGroup(
																			    FadeOut(lowercase_				,    run_time=0.5    )				,    MoveToTarget(lowercase_				,    run_time=0.5    )				,    FadeIn(lowercase_				,    run_time=0.5    )				,    lag_ratio=0.2    )

																			self.play(lowercase_    )

																			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:
																															_snake_case						:					Union[str, Any]    =   0.7

																									self.play(
																									    Circumscribe(model_arr[i]				,    **lowercase_    )				,    Circumscribe(cpu_left_col_base[i]				,    **lowercase_    )				,    Circumscribe(cpu_left_col_base[i + 1]				,    color=lowercase_				,    **lowercase_    )				,    Circumscribe(gpu_rect[0]				,    color=lowercase_				,    **lowercase_    )				,    Circumscribe(model_arr[i + 1]				,    color=lowercase_				,    **lowercase_    )				,    )
																									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.02				,    buff=0.2    )

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

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

																			_snake_case						:					Union[str, Any]    =   a_c
																			_snake_case						:					List[Any]    =   a_c.copy()

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

													_snake_case						:					Union[str, Any]    =   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(lowercase_				,    run_time=3    )				,    MoveToTarget(lowercase_    )    )

													self.wait()
def  snake_case						(__lowercase						)	->	list[int]:

						'''simple docstring'''



						if num <= 0:
												raise ValueError("Input must be a positive integer"						)

						_snake_case						:					Any    =   [True] * (num + 1)

						_snake_case						:					str    =   2
						while p * p <= num:
												if primes[p]:
																		for i in range(p * p ,      num + 1 ,      __lowercase						):
																								_snake_case						:					Optional[int]    =   False
												p += 1

						return [prime for prime in range(2 ,      num + 1						) if primes[prime]]


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				__SCREAMING_SNAKE_CASE						:   Any         =			int(input('Enter a positive integer: ').strip())
				print(prime_sieve_eratosthenes(user_num))