from __future__ import annotations




def    lowerCAmelCase_ (     __A							)     ->				int:







      '''simple docstring'''


      for i in range(1,  len(matrix[0]							)							):
            matrix[0][i] += matrix[0][i - 1]

      # preprocessing the first column
      for i in range(1,  len(__A							)							):
            matrix[i][0] += matrix[i - 1][0]

      # updating the path cost for current position
      for i in range(1,  len(__A							)							):
            for j in range(1,  len(matrix[0]							)							):
                  matrix[i][j] += min(matrix[i - 1][j],  matrix[i][j - 1]							)

      return matrix[-1][-1]


if __name__ == "__main__":
      import doctest

      doctest.testmod()




from manim import *





class      A							(				UpperCAmelCase_     ):


   def 			lowercase_      (self     :						Union[str, Any]		)						->				List[str]:
         """simple docstring"""



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

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

         UpperCAmelCase__								=  [mem.copy() for i in range(6		)]
         UpperCAmelCase__								=  [mem.copy() for i in range(6		)]
         UpperCAmelCase__								=  VGroup(*__UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0		)
         UpperCAmelCase__								=  VGroup(*__UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0		)
         UpperCAmelCase__								=  VGroup(__UpperCAmelCase       ,  __UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0		)
         UpperCAmelCase__								=  Text("CPU"       ,  font_size=2_4		)
         UpperCAmelCase__								=  Group(__UpperCAmelCase       ,  __UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0.5       ,  aligned_edge=__UpperCAmelCase		)
         cpu.move_to([-2.5, -0.5, 0]		)
         self.add(__UpperCAmelCase		)

         UpperCAmelCase__								=  [mem.copy() for i in range(4		)]
         UpperCAmelCase__								=  VGroup(*__UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0		)
         UpperCAmelCase__								=  Text("GPU"       ,  font_size=2_4		)
         UpperCAmelCase__								=  Group(__UpperCAmelCase       ,  __UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0.5       ,  aligned_edge=__UpperCAmelCase		)
         gpu.move_to([-1, -1, 0]		)
         self.add(__UpperCAmelCase		)

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

         UpperCAmelCase__								=  Text("Model"       ,  font_size=2_4		)
         UpperCAmelCase__								=  Group(__UpperCAmelCase       ,  __UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0.5       ,  aligned_edge=__UpperCAmelCase		)
         model.move_to([3, -1.0, 0]		)
         self.add(__UpperCAmelCase		)

         UpperCAmelCase__								=  []
         UpperCAmelCase__								=  []

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

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

         UpperCAmelCase__								=  [meta_mem.copy() for i in range(6		)]
         UpperCAmelCase__								=  [meta_mem.copy() for i in range(6		)]
         UpperCAmelCase__								=  VGroup(*__UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0		)
         UpperCAmelCase__								=  VGroup(*__UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0		)
         UpperCAmelCase__								=  VGroup(__UpperCAmelCase       ,  __UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0		)
         UpperCAmelCase__								=  Text("Disk"       ,  font_size=2_4		)
         UpperCAmelCase__								=  Group(__UpperCAmelCase       ,  __UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0.5       ,  aligned_edge=__UpperCAmelCase		)
         disk.move_to([-4, -1.25, 0]		)
         self.add(__UpperCAmelCase       ,  __UpperCAmelCase		)

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

         UpperCAmelCase__								=  MarkupText(
             f"""<b>Key:</b>\n\n<span fgcolor='{YELLOW}'>●</span> Empty Model"""       ,  font_size=1_8       ,  )

         key_text.move_to([-5, 2.4, 0]		)

         self.add(__UpperCAmelCase       ,  __UpperCAmelCase		)

         UpperCAmelCase__								=  MarkupText(
             f"""<span fgcolor='{BLUE}'>●</span> Checkpoint"""       ,  font_size=1_8       ,  )

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

         UpperCAmelCase__								=  MarkupText(
             f"""Now watch as an input is passed through the model\nand how the memory is utilized and handled."""       ,  font_size=2_4       ,  )
         step_a.move_to([2, 2, 0]		)

         self.play(Write(__UpperCAmelCase		)		)

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

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

         UpperCAmelCase__								=  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=2_4       ,  )
         step_a.move_to([2, 2, 0]		)

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

         UpperCAmelCase__								=  {"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]		)		)

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

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

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

         UpperCAmelCase__								=  MarkupText(f"""Inference on a model too large for GPU memory\nis successfully completed."""       ,  font_size=2_4		)
         step_a.move_to([2, 2, 0]		)

         self.play(Write(__UpperCAmelCase       ,  run_time=3		)       ,  MoveToTarget(__UpperCAmelCase		)		)

         self.wait()



