


'''simple docstring'''

import numpy as np

lowercase__				     =		[
    ["a", "b", "c", "d", "e"],
    ["f", "g", "h", "i", "k"],
    ["l", "m", "n", "o", "p"],
    ["q", "r", "s", "t", "u"],
    ["v", "w", "x", "y", "z"],
]





class 						__SCREAMING_SNAKE_CASE					:






     def __init__(			self		)       ->    None:
          _a						=		np.array(__UpperCamelCase		)






     def  a_					(			self     ,							__UpperCamelCase		)       ->    np.ndarray:
          _a			,			_a						=		np.where(letter == self.SQUARE		)
          _a						=		np.concatenate([indexa + 1, indexa + 1]		)
          return indexes






     def  a_					(			self     ,							__UpperCamelCase     ,							__UpperCamelCase		)       ->    str:
          _a						=		self.SQUARE[indexa - 1, indexa - 1]
          return letter






     def  a_					(			self     ,							__UpperCamelCase		)       ->    str:
          _a						=		message.lower()
          _a						=		message.replace(" "     ,							""		)
          _a						=		message.replace("j"     ,							"i"		)

          _a						=		np.empty((2, len(__UpperCamelCase		))		)
          for letter_index in range(len(__UpperCamelCase		)		):
               _a						=		self.letter_to_numbers(message[letter_index]		)

               _a						=		numbers[0]
               _a						=		numbers[1]

          _a						=		first_step.reshape(2 * len(__UpperCamelCase		)		)
          _a						=		""
          for numbers_index in range(len(__UpperCamelCase		)		):
               _a						=		int(second_step[numbers_index * 2]		)
               _a						=		int(second_step[(numbers_index * 2) + 1]		)
               _a						=		self.numbers_to_letter(__UpperCamelCase     ,							__UpperCamelCase		)
               _a						=		encoded_message + letter

          return encoded_message






     def  a_					(			self     ,							__UpperCamelCase		)       ->    str:
          _a						=		message.lower()
          message.replace(" "     ,							""		)
          _a						=		np.empty(2 * len(__UpperCamelCase		)		)
          for letter_index in range(len(__UpperCamelCase		)		):
               _a						=		self.letter_to_numbers(message[letter_index]		)
               _a						=		numbers[0]
               _a						=		numbers[1]

          _a						=		first_step.reshape((2, len(__UpperCamelCase		))		)
          _a						=		""
          for numbers_index in range(len(__UpperCamelCase		)		):
               _a						=		int(second_step[0, numbers_index]		)
               _a						=		int(second_step[1, numbers_index]		)
               _a						=		self.numbers_to_letter(__UpperCamelCase     ,							__UpperCamelCase		)
               _a						=		decoded_message + letter

          return decoded_message





'''simple docstring'''

from manim import *





class 						__SCREAMING_SNAKE_CASE					(      lowerCamelCase__ ):






     def  a_					(			self		)       ->    str:
          _a						=		Rectangle(height=0.5     ,							width=0.5		)
          _a						=		Rectangle(height=0.46     ,							width=0.46		).set_stroke(width=0		)

          _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(1		)]
          _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.align_to(__UpperCamelCase     ,							__UpperCamelCase		)
          gpu.set_x(gpu.get_x() - 1		)

          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.play(
              Create(__UpperCamelCase     ,							run_time=1		)     ,							Create(__UpperCamelCase     ,							run_time=1		)     ,							Create(__UpperCamelCase     ,							run_time=1		)     ,							)

          _a						=		MarkupText(
              f"First, an empty model skeleton is loaded\ninto <span fgcolor='{YELLOW}'>memory</span> without using much RAM."     ,							font_size=24     ,							)

          _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]		)

          step_a.move_to([2, 2, 0]		)
          self.play(Write(__UpperCamelCase     ,							run_time=2.5		)     ,							Write(__UpperCamelCase		)     ,							Write(__UpperCamelCase		)		)

          self.add(__UpperCamelCase		)

          _a						=		[]
          _a						=		[]
          _a						=		[]
          for i, rect in enumerate(__UpperCamelCase		):
               _a						=		Rectangle(height=0.46     ,							width=0.46		).set_stroke(width=0.0		).set_fill(__UpperCamelCase     ,							opacity=0.7		)
               cpu_target.move_to(__UpperCamelCase		)
               cpu_target.generate_target()
               _a						=		0.46 / 4
               _a						=		0.46 / 3

               if i == 0:
                    cpu_target.target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT		)     ,							buff=0.02     ,							direction=__UpperCamelCase		)
                    cpu_target.target.set_x(cpu_target.target.get_x() + 0.1		)
               elif i == 3:
                    cpu_target.target.next_to(cpu_targs[0].target     ,							direction=__UpperCamelCase     ,							buff=0.0		)
               else:
                    cpu_target.target.next_to(cpu_targs[i - 1].target     ,							direction=__UpperCamelCase     ,							buff=0.0		)
               cpu_targs.append(__UpperCamelCase		)

               first_animations.append(rect.animate(run_time=0.5		).set_stroke(__UpperCamelCase		)		)
               second_animations.append(MoveToTarget(__UpperCamelCase     ,							run_time=1.5		)		)

          self.play(*__UpperCamelCase		)
          self.play(*__UpperCamelCase		)

          self.wait()

