
"""simple docstring"""



from manim import *




class 		a_    (			__lowerCAmelCase						):







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






        '''simple docstring'''






        _UpperCAmelCase        = Rectangle(height=0.5  ,       width=0.5  )
        _UpperCAmelCase        = Rectangle(height=0.4_6  ,       width=0.4_6  ).set_stroke(width=0  )

        _UpperCAmelCase        = Rectangle(height=0.2_5  ,       width=0.2_5  )

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

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

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

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

        _UpperCAmelCase        = []
        _UpperCAmelCase        = []

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

            _UpperCAmelCase        = Rectangle(height=0.4_6  ,       width=0.4_6  ).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        = [meta_mem.copy() for i in range(6  )]
        _UpperCAmelCase        = [meta_mem.copy() for i in range(6  )]
        _UpperCAmelCase        = VGroup(*lowerCamelCase_  ).arrange(lowerCamelCase_  ,       buff=0  )
        _UpperCAmelCase        = VGroup(*lowerCamelCase_  ).arrange(lowerCamelCase_  ,       buff=0  )
        _UpperCAmelCase        = VGroup(lowerCamelCase_  ,       lowerCamelCase_  ).arrange(lowerCamelCase_  ,       buff=0  )
        _UpperCAmelCase        = Text("""Disk"""  ,       font_size=24  )
        _UpperCAmelCase        = Group(lowerCamelCase_  ,       lowerCamelCase_  ).arrange(lowerCamelCase_  ,       buff=0.5  ,       aligned_edge=lowerCamelCase_  )
        disk.move_to([-4, -1.2_5, 0]  )
        self.add(lowerCamelCase_  ,       lowerCamelCase_  )

        _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=18  ,       )

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

        self.add(lowerCamelCase_  ,       lowerCamelCase_  )

        _UpperCAmelCase        = 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        = 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        = 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.0_2  )
        self.play(MoveToTarget(lowerCamelCase_  )  )

        self.play(FadeOut(lowerCamelCase_  )  )

        _UpperCAmelCase        = 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        = 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        = {"""run_time""": 1, """fade_in""": True, """fade_out""": True, """buff""": 0.0_2}

        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        = a.copy()
        for i in range(6  ):
            a_c.next_to(model_arr[i].get_right() + 0.0_2  ,       lowerCamelCase_  ,       buff=0.2  )

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

            _UpperCAmelCase        = 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        = 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.0_2  ,       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        = a_c
            _UpperCAmelCase        = a_c.copy()

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

        _UpperCAmelCase        = 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 __future__ import annotations
class SCREAMING_SNAKE_CASE_		:







   def __init__(     self						:						Dict   ,   lowerCamelCase_						:						str   ,   lowerCamelCase_						:						str				):





    """simple docstring"""


    UpperCamelCase  ,     UpperCamelCase			  =      text, pattern
    UpperCamelCase  ,     UpperCamelCase			  =      len(lowerCamelCase_				), len(lowerCamelCase_				)







   def 						lowerCamelCase_	(     self						:						List[Any]   ,   lowerCamelCase_						:						str				):





    """simple docstring"""


    for i in range(self.patLen - 1   ,   -1   ,   -1				):
     if char == self.pattern[i]:
      return i
    return -1







   def 						lowerCamelCase_	(     self						:						Union[str, Any]   ,   lowerCamelCase_						:						int				):





    """simple docstring"""


    for i in range(self.patLen - 1   ,   -1   ,   -1				):
     if self.pattern[i] != self.text[current_pos + i]:
      return current_pos + i
    return -1







   def 						lowerCamelCase_	(     self						:						Union[str, Any]				):





    """simple docstring"""


    UpperCamelCase			  =      []
    for i in range(self.textLen - self.patLen + 1				):
     UpperCamelCase			  =      self.mismatch_in_text(lowerCamelCase_				)
     if mismatch_index == -1:
      positions.append(lowerCamelCase_				)
     else:
      UpperCamelCase			  =      self.match_in_pattern(self.text[mismatch_index]				)
      UpperCamelCase			  =      (
          mismatch_index - match_index
      )  # shifting index lgtm [py/multiple-definition]
    return positions





_SCREAMING_SNAKE_CASE 		=      """ABAABA"""
_SCREAMING_SNAKE_CASE 		=      """AB"""
_SCREAMING_SNAKE_CASE 		=      BoyerMooreSearch(text, pattern)
_SCREAMING_SNAKE_CASE 		=      bms.bad_character_heuristic()

if len(positions) == 0:
     print("""No match found""")
else:
     print("""Pattern found in following positions: """)
     print(positions)
