






from manim import *




class 						UpperCAmelCase_  (		SCREAMING_SNAKE_CASE__    ):


						'''simple docstring'''




						def 					_lowerCAmelCase				(		self )       -> List[str]:
								snake_case_ :							Union[str, Any]         =				Rectangle(height=0.5						, width=0.5 )
								snake_case_ :							int         =				Rectangle(height=0.46						, width=0.46 ).set_stroke(width=0 )
								snake_case_ :							List[str]         =				Rectangle(height=0.25						, width=0.25 )

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

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

								snake_case_ :							List[Any]         =				[mem.copy() for i in range(6 )]
								snake_case_ :							Tuple         =				VGroup(*_SCREAMING_SNAKE_CASE ).arrange(_SCREAMING_SNAKE_CASE						, buff=0 )

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

								snake_case_ :							Union[str, Any]         =				[]
								snake_case_ :							Tuple         =				[]

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

										snake_case_ :							str         =				Rectangle(height=0.46 / 4						, width=0.46 / 3 ).set_stroke(width=0.0 ).set_fill(_SCREAMING_SNAKE_CASE						, opacity=0.7 )

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

								self.add(*_SCREAMING_SNAKE_CASE						, *_SCREAMING_SNAKE_CASE )

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

								snake_case_ :							Tuple         =				[]

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

								self.add(*_SCREAMING_SNAKE_CASE )

								snake_case_ :							Union[str, 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(_SCREAMING_SNAKE_CASE						, _SCREAMING_SNAKE_CASE )

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

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

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

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

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

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

												self.remove(
												    *_SCREAMING_SNAKE_CASE						, *_SCREAMING_SNAKE_CASE						, )

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

								snake_case_ :							Optional[int]         =				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(_SCREAMING_SNAKE_CASE						, run_time=3 ) )

								snake_case_ :							Dict         =				[]
								snake_case_ :							List[Any]         =				[]
								for i in range(6 ):
										snake_case_ :							Optional[int]         =				Arrow(start=_SCREAMING_SNAKE_CASE						, end=_SCREAMING_SNAKE_CASE						, color=_SCREAMING_SNAKE_CASE						, buff=0.5 )
										a.next_to(model_base[i].get_left()						, _SCREAMING_SNAKE_CASE						, buff=0.2 )
										arrows.append(_SCREAMING_SNAKE_CASE )
										animations.append(Write(_SCREAMING_SNAKE_CASE ) )
								self.play(*_SCREAMING_SNAKE_CASE )
								self.wait()








import math

def    lowerCAmelCase__		(			_a				:	int			):

		if 1 < number < 4:
				# 2 and 3 are primes
				return True
		elif number < 2 or number % 2 == 0 or number % 3 == 0:
				# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
				return False

		# All primes number are in format of 6k +/- 1
		for i in range(5     ,					int(math.sqrt(_a			) + 1			)     ,					6			):
				if number % i == 0 or number % (i + 2) == 0:
						return False
		return True

def    lowerCAmelCase__		(			_a				:	int = 60_08_51_47_51_43			):

		try:
				snake_case_ :							int         =				int(_a			)
		except (TypeError, ValueError):
				raise TypeError("Parameter n must be int or castable to int."			)
		if n <= 0:
				raise ValueError("Parameter n must be greater than or equal to one."			)
		snake_case_ :							Dict         =				0
		if is_prime(_a			):
				return n
		while n % 2 == 0:
				n //= 2
		if is_prime(_a			):
				return n
		for i in range(3     ,					int(math.sqrt(_a			)			) + 1     ,					2			):
				if n % i == 0:
						if is_prime(n // i			):
								snake_case_ :							List[Any]         =				n // i
								break
						elif is_prime(_a			):
								snake_case_ :							str         =				i
		return max_number


if __name__ == "__main__":
							print(F"""{solution() = }""")
