






'''simple docstring'''







from manim import *




class   __SCREAMING_SNAKE_CASE       (__A       ):


  """simple docstring"""


  def    _a       (			self	):






         """simple docstring"""


         a_						     =			Rectangle(height=0.5   ,	width=0.5	)
         a_						     =			Rectangle(height=0.46   ,	width=0.46	).set_stroke(width=0	)

         a_						     =			Rectangle(height=0.25   ,	width=0.25	)

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

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

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

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

         a_						     =			[]
         a_						     =			[]

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

                a_						     =			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__	)

         a_						     =			[meta_mem.copy() for i in range(6	)]
         a_						     =			[meta_mem.copy() for i in range(6	)]
         a_						     =			VGroup(*UpperCamelCase__	).arrange(UpperCamelCase__   ,	buff=0	)
         a_						     =			VGroup(*UpperCamelCase__	).arrange(UpperCamelCase__   ,	buff=0	)
         a_						     =			VGroup(UpperCamelCase__   ,	UpperCamelCase__	).arrange(UpperCamelCase__   ,	buff=0	)
         a_						     =			Text('Disk'   ,	font_size=24	)
         a_						     =			Group(UpperCamelCase__   ,	UpperCamelCase__	).arrange(UpperCamelCase__   ,	buff=0.5   ,	aligned_edge=UpperCamelCase__	)
         disk.move_to([-4, -1.25, 0]	)
         self.add(UpperCamelCase__   ,	UpperCamelCase__	)

         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(UpperCamelCase__   ,	UpperCamelCase__	)

         a_						     =			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__	)

         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(UpperCamelCase__	)	)

         a_						     =			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__	)	)

         a_						     =			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]	)

         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(UpperCamelCase__   ,	run_time=3	)	)

         a_						     =			{'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]	)	)

         a_						     =			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	)

                a_						     =			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:
                              a_						     =			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]	)	)

                a_						     =			a_c
                a_						     =			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	)   ,	)

         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(UpperCamelCase__   ,	run_time=3	)   ,	MoveToTarget(UpperCamelCase__	)	)

         self.wait()












'''simple docstring'''







def       __UpperCamelCase					(      lowercase_       :  int = 1_000_000   ):
       """simple docstring"""




       a_						     =			set(range(3   ,       lowercase_   ,       2   )   )
       primes.add(2   )
       for p in range(3   ,       lowercase_   ,       2   ):
              if p not in primes:
                     continue
              primes.difference_update(set(range(p * p   ,       lowercase_   ,       lowercase_   )   )   )

       a_						     =			[float(lowercase_   ) for n in range(limit + 1   )]

       for p in primes:
              for n in range(lowercase_   ,       limit + 1   ,       lowercase_   ):
                     phi[n] *= 1 - 1 / p

       return int(sum(phi[2:]   )   )


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




