



"""simple docstring"""
from manim import *



class       SCREAMING_SNAKE_CASE__  (					__lowerCAmelCase ):

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Union[str, Any]	=	Rectangle(height=0.5      ,     width=0.5						)
    UpperCAmelCase	:					str	=	Rectangle(height=0.46      ,     width=0.46						).set_stroke(width=0						)

    UpperCAmelCase	:					str	=	Rectangle(height=0.25      ,     width=0.25						)

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

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

    UpperCAmelCase	:					int	=	[mem.copy() for i in range(6						)]
    UpperCAmelCase	:					str	=	VGroup(*lowerCAmelCase_						).arrange(lowerCAmelCase_      ,     buff=0						)

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

    UpperCAmelCase	:					Union[str, Any]	=	[]
    UpperCAmelCase	:					List[str]	=	[]

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

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

    self.add(*lowerCAmelCase_      ,     *lowerCAmelCase_						)

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

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

    UpperCAmelCase	:					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(lowerCAmelCase_      ,     lowerCAmelCase_						)

    UpperCAmelCase	:					List[Any]	=	MarkupText(
        F"<span fgcolor=\'{BLUE}\'>●</span> Checkpoint"      ,     font_size=18      ,     )

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

    UpperCAmelCase	:					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(lowerCAmelCase_						)						)

    UpperCAmelCase	:					Optional[Any]	=	Square(0.3						)
    input.set_fill(lowerCAmelCase_      ,     opacity=1.0						)
    input.set_stroke(width=0.0						)
    input.next_to(model_base[0]      ,     lowerCAmelCase_      ,     buff=0.5						)

    self.play(Write(lowerCAmelCase_						)						)

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

    self.play(FadeOut(lowerCAmelCase_						)						)

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

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

    UpperCAmelCase	:					List[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(lowerCAmelCase_      ,     run_time=3						)						)

    UpperCAmelCase	:					Optional[int]	=	{"""run_time""": 1, """fade_in""": True, """fade_out""": True, """buff""": 0.02}

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

    UpperCAmelCase	:					List[str]	=	a.copy()
    for i in range(6						):
     a_c.next_to(model_arr[i].get_right() + 0.02      ,     lowerCAmelCase_      ,     buff=0.2						)

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

     UpperCAmelCase	:					int	=	AnimationGroup(
         FadeOut(lowerCAmelCase_      ,     run_time=0.5						)      ,     MoveToTarget(lowerCAmelCase_      ,     run_time=0.5						)      ,     FadeIn(lowerCAmelCase_      ,     run_time=0.5						)      ,     lag_ratio=0.2						)

     self.play(lowerCAmelCase_						)

     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:
       UpperCAmelCase	:					Optional[int]	=	0.7

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

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

     UpperCAmelCase	:					Tuple	=	a_c
     UpperCAmelCase	:					Optional[Any]	=	a_c.copy()

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

    UpperCAmelCase	:					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(lowerCAmelCase_      ,     run_time=3						)      ,     MoveToTarget(lowerCAmelCase_						)						)

    self.wait()

from math import isqrt, loga






def  snake_case  (       snake_case__			:int)						->   list[int]:
       _A        =  [True] * max_number
       for i in range(2   ,	isqrt(max_number - 1) + 1):
              if is_prime[i]:
                     for j in range(i**2   ,	snake_case__   ,	snake_case__):
                            _A        =  False

       return [i for i in range(2   ,	snake_case__) if is_prime[i]]






def  snake_case  (       snake_case__			:int = 800_800   ,	snake_case__			:int = 800_800)						->   int:
       _A        =  degree * loga(snake_case__)
       _A        =  int(snake_case__)
       _A        =  calculate_prime_numbers(snake_case__)

       _A        =  0
       _A        =  0
       _A        =  len(snake_case__) - 1
       while left < right:
              while (
                  prime_numbers[right] * loga(prime_numbers[left])
                  + prime_numbers[left] * loga(prime_numbers[right])
                  > upper_bound
              ):
                     right -= 1
              hybrid_integers_count += right - left
              left += 1

       return hybrid_integers_count


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




