
from manim import *




class        SCREAMING_SNAKE_CASE__					(     UpperCAmelCase ):





	'''simple docstring'''



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


				'''simple docstring'''


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

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

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

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

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

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

				_snake_case          =      []
				_snake_case          =      []

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

							_snake_case          =      Rectangle(height=0.46      ,  width=0.46     ).set_stroke(width=0.0     ).set_fill(_SCREAMING_SNAKE_CASE      ,  opacity=0.8     )
							cpu_target.move_to(cpu_left_col_base[i]     )
							model_cpu_arr.append(_SCREAMING_SNAKE_CASE     )

				self.add(*_SCREAMING_SNAKE_CASE      ,  *_SCREAMING_SNAKE_CASE     )

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

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

				_snake_case          =      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(_SCREAMING_SNAKE_CASE      ,  _SCREAMING_SNAKE_CASE     )

				_snake_case          =      MarkupText(
				    f'''<span fgcolor=\'{BLUE}\'>●</span> Checkpoint'''      ,  font_size=18      ,  )

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

				_snake_case          =      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(_SCREAMING_SNAKE_CASE     )     )

				_snake_case          =      Square(0.3     )
				input.set_fill(_SCREAMING_SNAKE_CASE      ,  opacity=1.0     )
				input.set_stroke(width=0.0     )
				input.next_to(model_base[0]      ,  _SCREAMING_SNAKE_CASE      ,  buff=0.5     )

				self.play(Write(_SCREAMING_SNAKE_CASE     )     )

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

				self.play(FadeOut(_SCREAMING_SNAKE_CASE     )     )

				_snake_case          =      Arrow(start=_SCREAMING_SNAKE_CASE      ,  end=_SCREAMING_SNAKE_CASE      ,  color=_SCREAMING_SNAKE_CASE      ,  buff=0.5     )
				a.next_to(model_arr[0].get_left()      ,  _SCREAMING_SNAKE_CASE      ,  buff=0.2     )

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

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

				_snake_case          =      {'''run_time''': 1, '''fade_in''': True, '''fade_out''': True, '''buff''': 0.02}

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

				_snake_case          =      a.copy()
				for i in range(6     ):
							a_c.next_to(model_arr[i].get_right() + 0.02      ,  _SCREAMING_SNAKE_CASE      ,  buff=0.2     )

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

							_snake_case          =      AnimationGroup(
							    FadeOut(_SCREAMING_SNAKE_CASE      ,  run_time=0.5     )      ,  MoveToTarget(_SCREAMING_SNAKE_CASE      ,  run_time=0.5     )      ,  FadeIn(_SCREAMING_SNAKE_CASE      ,  run_time=0.5     )      ,  lag_ratio=0.2     )

							self.play(_SCREAMING_SNAKE_CASE     )

							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:
													_snake_case          =      0.7

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

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

							_snake_case          =      a_c
							_snake_case          =      a_c.copy()

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

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

				self.wait()

import random




class        SCREAMING_SNAKE_CASE__					:





	'''simple docstring'''



	@staticmethod
	def 			A							(  lowercase     :   str     ):


				'''simple docstring'''


				_snake_case          =      [ord(lowercase     ) for i in text]
				_snake_case          =      []
				_snake_case          =      []
				for i in plain:
							_snake_case          =      random.randint(1      ,  300     )
							_snake_case          =      (i + k) * k
							cipher.append(lowercase     )
							key.append(lowercase     )
				return cipher, key





	@staticmethod
	def 			A							(  lowercase     :   list[int]      ,  lowercase     :   list[int]     ):


				'''simple docstring'''


				_snake_case          =      []
				for i in range(len(lowercase     )     ):
							_snake_case          =      int((cipher[i] - (key[i]) ** 2) / key[i]     )
							plain.append(chr(lowercase     )     )
				return "".join(lowercase     )


if __name__ == "__main__":
			_lowerCamelCase   ,					_lowerCamelCase	:    Optional[int]          =      Onepad().encrypt('''Hello''')
			print(c, k)
			print(Onepad().decrypt(c, k))