

from manim import *






class _UpperCamelCase							(							a__      ):
			'''simple docstring'''







			def 							__UpperCamelCase       (	self							:       Union[str, Any]		)							->				str:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					Any    =				Rectangle(height=0.5					,					width=0.5		)
				SCREAMING_SNAKE_CASE      :					Dict    =				Rectangle(height=0.46					,					width=0.46		).set_stroke(width=0		)

				SCREAMING_SNAKE_CASE      :					Tuple    =				Rectangle(height=0.25					,					width=0.25		)

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

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

				SCREAMING_SNAKE_CASE      :					Optional[int]    =				[mem.copy() for i in range(6		)]
				SCREAMING_SNAKE_CASE      :					Any    =				VGroup(*_UpperCAmelCase		).arrange(_UpperCAmelCase					,					buff=0		)

				SCREAMING_SNAKE_CASE      :					List[str]    =				Text("Model"					,					font_size=24		)
				SCREAMING_SNAKE_CASE      :					str    =				Group(_UpperCAmelCase					,					_UpperCAmelCase		).arrange(_UpperCAmelCase					,					buff=0.5					,					aligned_edge=_UpperCAmelCase		)
				model.move_to([3, -1.0, 0]		)
				self.add(_UpperCAmelCase		)

				SCREAMING_SNAKE_CASE      :					Tuple    =				[]
				SCREAMING_SNAKE_CASE      :					Dict    =				[]

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

					SCREAMING_SNAKE_CASE      :					Union[str, Any]    =				Rectangle(height=0.46					,					width=0.46		).set_stroke(width=0.0		).set_fill(_UpperCAmelCase					,					opacity=0.8		)
					cpu_target.move_to(cpu_left_col_base[i]		)
					model_cpu_arr.append(_UpperCAmelCase		)

				self.add(*_UpperCAmelCase					,					*_UpperCAmelCase		)

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

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

				SCREAMING_SNAKE_CASE      :					Optional[Any]    =				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(_UpperCAmelCase					,					_UpperCAmelCase		)

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

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

				SCREAMING_SNAKE_CASE      :					List[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(_UpperCAmelCase		)		)

				SCREAMING_SNAKE_CASE      :					str    =				Square(0.3		)
				input.set_fill(_UpperCAmelCase					,					opacity=1.0		)
				input.set_stroke(width=0.0		)
				input.next_to(model_base[0]					,					_UpperCAmelCase					,					buff=0.5		)

				self.play(Write(_UpperCAmelCase		)		)

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

				self.play(FadeOut(_UpperCAmelCase		)		)

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

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

				SCREAMING_SNAKE_CASE      :					str    =				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(_UpperCAmelCase					,					run_time=3		)		)

				SCREAMING_SNAKE_CASE      :					int    =				{'run_time': 1, 'fade_in': True, 'fade_out': True, 'buff': 0.02}

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

				SCREAMING_SNAKE_CASE      :					Dict    =				a.copy()
				for i in range(6		):
					a_c.next_to(model_arr[i].get_right() + 0.02					,					_UpperCAmelCase					,					buff=0.2		)

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

					SCREAMING_SNAKE_CASE      :					int    =				AnimationGroup(
					    FadeOut(_UpperCAmelCase					,					run_time=0.5		)					,					MoveToTarget(_UpperCAmelCase					,					run_time=0.5		)					,					FadeIn(_UpperCAmelCase					,					run_time=0.5		)					,					lag_ratio=0.2		)

					self.play(_UpperCAmelCase		)

					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:
							SCREAMING_SNAKE_CASE      :					Dict    =				0.7

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

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

					SCREAMING_SNAKE_CASE      :					Optional[Any]    =				a_c
					SCREAMING_SNAKE_CASE      :					Optional[int]    =				a_c.copy()

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

				SCREAMING_SNAKE_CASE      :					str    =				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(_UpperCAmelCase					,					run_time=3		)					,					MoveToTarget(_UpperCAmelCase		)		)

				self.wait()






'''simple docstring'''




import math

import qiskit






def        _lowerCAmelCase			(  __snake_case  : int = 1 ,							__snake_case  : int = 1 ,							__snake_case  : int = 1			)     ->     qiskit.result.counts.Counts:
     if (
         isinstance(__snake_case ,							__snake_case			)
         or isinstance(__snake_case ,							__snake_case			)
         or isinstance(__snake_case ,							__snake_case			)
     ):
          raise TypeError('inputs must be integers.'			)

     if (input_a < 0) or (input_a < 0) or (carry_in < 0):
          raise ValueError('inputs must be positive.'			)

     if (
         (math.floor(__snake_case			) != input_a)
         or (math.floor(__snake_case			) != input_a)
         or (math.floor(__snake_case			) != carry_in)
     ):
          raise ValueError('inputs must be exact integers.'			)

     if (input_a > 2) or (input_a > 2) or (carry_in > 2):
          raise ValueError('inputs must be less or equal to 2.'			)

     # build registers
     __A						: int      =       qiskit.QuantumRegister(4 ,							'qr'			)
     __A						: Optional[int]      =       qiskit.ClassicalRegister(2 ,							'cr'			)
     # list the entries
     __A						: Union[str, Any]      =       [input_a, input_a, carry_in]

     __A						: Dict      =       qiskit.QuantumCircuit(__snake_case ,							__snake_case			)

     for i in range(0 ,							3			):
          if entry[i] == 2:
               quantum_circuit.h(__snake_case			)  # for hadamard entries
          elif entry[i] == 1:
               quantum_circuit.x(__snake_case			)  # for 1 entries
          elif entry[i] == 0:
               quantum_circuit.i(__snake_case			)  # for 0 entries

    # build the circuit
     quantum_circuit.ccx(0 ,							1 ,							3			)  # ccx = toffoli gate
     quantum_circuit.cx(0 ,							1			)
     quantum_circuit.ccx(1 ,							2 ,							3			)
     quantum_circuit.cx(1 ,							2			)
     quantum_circuit.cx(0 ,							1			)

     quantum_circuit.measure([2, 3] ,							__snake_case			)  # measure the last two qbits

     __A						: str      =       qiskit.Aer.get_backend('aer_simulator'			)
     __A						: Any      =       qiskit.execute(__snake_case ,							__snake_case ,							shots=10_00			)

     return job.result().get_counts(__snake_case			)


if __name__ == "__main__":
  print(f"""Total sum count for state is: {quantum_full_adder(1, 1, 1)}""")