






from manim import *





class 	snake_case__ (							_lowerCAmelCase				):
	def       __magic_name__    (    self			)							->				Any:
							__magic_name__      :       Any       						= Rectangle(height=0.5      ,       width=0.5			)
							__magic_name__      :       List[str]       						= Rectangle(height=0.4_6      ,       width=0.4_6			).set_stroke(width=0			)

							__magic_name__      :       List[str]       						= Rectangle(height=0.2_5      ,       width=0.2_5			)

							__magic_name__      :       Optional[Any]       						= [mem.copy() for i in range(6			)]
							__magic_name__      :       Tuple       						= [mem.copy() for i in range(6			)]
							__magic_name__      :       Dict       						= VGroup(*_SCREAMING_SNAKE_CASE			).arrange(_SCREAMING_SNAKE_CASE      ,       buff=0			)
							__magic_name__      :       Optional[int]       						= VGroup(*_SCREAMING_SNAKE_CASE			).arrange(_SCREAMING_SNAKE_CASE      ,       buff=0			)
							__magic_name__      :       str       						= VGroup(_SCREAMING_SNAKE_CASE      ,       _SCREAMING_SNAKE_CASE			).arrange(_SCREAMING_SNAKE_CASE      ,       buff=0			)
							__magic_name__      :       Dict       						= Text("""CPU"""      ,       font_size=24			)
							__magic_name__      :       List[str]       						= 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			)

							__magic_name__      :       Union[str, Any]       						= [mem.copy() for i in range(4			)]
							__magic_name__      :       Tuple       						= VGroup(*_SCREAMING_SNAKE_CASE			).arrange(_SCREAMING_SNAKE_CASE      ,       buff=0			)
							__magic_name__      :       Union[str, Any]       						= Text("""GPU"""      ,       font_size=24			)
							__magic_name__      :       Optional[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			)

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

							__magic_name__      :       int       						= Text("""Model"""      ,       font_size=24			)
							__magic_name__      :       List[str]       						= 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			)

							__magic_name__      :       Union[str, Any]       						= []
							__magic_name__      :       str       						= []

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

													__magic_name__      :       Optional[int]       						= Rectangle(height=0.4_6      ,       width=0.4_6			).set_stroke(width=0.0			).set_fill(_SCREAMING_SNAKE_CASE      ,       opacity=0.8			)
													cpu_target.move_to(cpu_left_col_base[i]			)
													model_cpu_arr.append(_SCREAMING_SNAKE_CASE			)

							self.add(*_SCREAMING_SNAKE_CASE      ,       *_SCREAMING_SNAKE_CASE			)

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

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

							__magic_name__      :       Optional[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			)

							__magic_name__      :       Dict       						= 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			)

							__magic_name__      :       str       						= 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(_SCREAMING_SNAKE_CASE			)			)

							__magic_name__      :       Tuple       						= Square(0.3			)
							input.set_fill(_SCREAMING_SNAKE_CASE      ,       opacity=1.0			)
							input.set_stroke(width=0.0			)
							input.next_to(model_base[0]      ,       _SCREAMING_SNAKE_CASE      ,       buff=0.5			)

							self.play(Write(_SCREAMING_SNAKE_CASE			)			)

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

							self.play(FadeOut(_SCREAMING_SNAKE_CASE			)			)

							__magic_name__      :       str       						= Arrow(start=_SCREAMING_SNAKE_CASE      ,       end=_SCREAMING_SNAKE_CASE      ,       color=_SCREAMING_SNAKE_CASE      ,       buff=0.5			)
							a.next_to(model_arr[0].get_left()      ,       _SCREAMING_SNAKE_CASE      ,       buff=0.2			)

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

							__magic_name__      :       Tuple       						= 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(_SCREAMING_SNAKE_CASE      ,       run_time=3			)			)

							__magic_name__      :       Optional[Any]       						= {'''run_time''': 1, '''fade_in''': True, '''fade_out''': True, '''buff''': 0.0_2}

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

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

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

													__magic_name__      :       Optional[int]       						= AnimationGroup(
													    FadeOut(_SCREAMING_SNAKE_CASE      ,       run_time=0.5			)      ,       MoveToTarget(_SCREAMING_SNAKE_CASE      ,       run_time=0.5			)      ,       FadeIn(_SCREAMING_SNAKE_CASE      ,       run_time=0.5			)      ,       lag_ratio=0.2			)

													self.play(_SCREAMING_SNAKE_CASE			)

													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:
																									__magic_name__      :       List[Any]       						= 0.7

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

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

													__magic_name__      :       Dict       						= a_c
													__magic_name__      :       int       						= a_c.copy()

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

							__magic_name__      :       List[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(_SCREAMING_SNAKE_CASE      ,       run_time=3			)      ,       MoveToTarget(_SCREAMING_SNAKE_CASE			)			)

							self.wait()








from decimal import Decimal, getcontext
from math import ceil, factorial

def    UpperCamelCase						(	_A			):






						"""simple docstring"""







						if not isinstance(_A,   _A			):
												raise TypeError("""Undefined for non-integers"""			)
						elif precision < 1:
												raise ValueError("""Undefined for non-natural numbers"""			)

						__magic_name__      :       Dict       						= precision
						__magic_name__      :       str       						= ceil(precision / 14			)
						__magic_name__      :       List[str]       						= 426880 * Decimal(10005			).sqrt()
						__magic_name__      :       List[Any]       						= 1
						__magic_name__      :       Dict       						= 13591409
						__magic_name__      :       Tuple       						= Decimal(_A			)
						for k in range(1,   _A			):
												__magic_name__      :       List[Any]       						= factorial(6 * k			) // (factorial(3 * k			) * factorial(_A			) ** 3)
												linear_term += 545140134
												exponential_term *= -262537412640768000
												partial_sum += Decimal(multinomial_term * linear_term			) / exponential_term
						return str(constant_term / partial_sum			)[:-1]


if __name__ == "__main__":
		__magic_name__:					Tuple							=     50
		print(F"""The first {n} digits of pi is: {pi(n)}""")
