


from manim import *
class 	UpperCAmelCase_					(					UpperCamelCase    ):

   '''simple docstring'''




   def _snake_case    (		self ):






     """simple docstring"""





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

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

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

     lowerCamelCase :					Union[str, Any]    =				[mem.copy() for i in range(6 )]
     lowerCamelCase :					Any    =				VGroup(*__A ).arrange(__A						,				buff=0 )

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

     lowerCamelCase :					Tuple    =				[]
     for i, rect in enumerate(__A ):
       rect.set_stroke(__A )
       # target = fill.copy().set_fill(YELLOW, opacity=0.7)
       # target.move_to(rect)
       # self.add(target)

       lowerCamelCase :					str    =				Rectangle(height=0.46 / 4						,				width=0.46 / 3 ).set_stroke(width=0.0 ).set_fill(__A						,				opacity=0.7 )

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

     lowerCamelCase :					Any    =				[mem.copy() for i in range(6 )]
     lowerCamelCase :					Optional[Any]    =				VGroup(*__A ).arrange(__A						,				buff=0 )

     lowerCamelCase :					Optional[int]    =				Text("Loaded Checkpoint"						,				font_size=24 )
     lowerCamelCase :					Optional[int]    =				Group(__A						,				__A ).arrange(__A						,				aligned_edge=__A						,				buff=0.4 )
     checkpoint.move_to([3, 0.5, 0] )

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

     lowerCamelCase :					Tuple    =				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(__A						,				__A )

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

     blue_text.next_to(__A						,				DOWN * 2.4						,				aligned_edge=key_text.get_left() )

     lowerCamelCase :					Union[str, Any]    =				MarkupText(
         F"""Next, a <i><span fgcolor=\"{BLUE}\">second</span></i> model is loaded into memory,\nwith the weights of a <span fgcolor=\"{BLUE}\">single shard</span>."""						,				font_size=24						,				)
     step_a.move_to([2, 2, 0] )
     self.play(Write(__A )						,				Write(__A ) )

     self.play(Write(__A						,				run_time=1 )						,				Create(__A						,				run_time=1 ) )

     lowerCamelCase :					Any    =				[]
     lowerCamelCase :					List[Any]    =				[]
     for i, rect in enumerate(__A ):
       lowerCamelCase :					Tuple    =				fill.copy().set_fill(__A						,				opacity=0.7 )
       target.move_to(__A )
       first_animations.append(GrowFromCenter(__A						,				run_time=1 ) )

       lowerCamelCase :					int    =				target.copy()
       cpu_target.generate_target()
       if i < 5:
         cpu_target.target.move_to(cpu_left_col_base[i + 1] )
       else:
         cpu_target.target.move_to(cpu_right_col_base[i - 5] )
       second_animations.append(MoveToTarget(__A						,				run_time=1.5 ) )

     self.play(*__A )
     self.play(*__A )
     self.wait()







def 		lowercase_(  SCREAMING_SNAKE_CASE_ = 4000000	):


  '''simple docstring'''

  lowerCamelCase :					Any    =				[0, 1]
  lowerCamelCase :					Union[str, Any]    =				0
  while fib[i] <= n:
    fib.append(fib[i] + fib[i + 1]	)
    if fib[i + 2] > n:
      break
    i += 1
  lowerCamelCase :					Union[str, Any]    =				0
  for j in range(len(SCREAMING_SNAKE_CASE_	) - 1	):
    if fib[j] % 2 == 0:
      total += fib[j]

  return total


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



