






"""simple docstring"""





from manim import *
class    __lowerCamelCase    (  _a  ):

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    Rectangle(height=0.5 ,				width=0.5      )
       UpperCamelCase__         =    Rectangle(height=0.46 ,				width=0.46      ).set_stroke(width=0      )

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

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

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

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

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

           UpperCamelCase__         =    Rectangle(height=0.46 / 4 ,				width=0.46 / 3      ).set_stroke(width=0.0      ).set_fill(snake_case_ ,				opacity=0.7      )

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

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

       UpperCamelCase__         =    Text('Loaded Checkpoint' ,				font_size=24      )
       UpperCamelCase__         =    Group(snake_case_ ,				snake_case_      ).arrange(snake_case_ ,				aligned_edge=snake_case_ ,				buff=0.4      )
       checkpoint.move_to([3, 0.5, 0]      )

       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(snake_case_ ,				snake_case_      )

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

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

       UpperCamelCase__         =    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(snake_case_      ) ,				Write(snake_case_      )      )

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

       UpperCamelCase__         =    []
       UpperCamelCase__         =    []
       for i, rect in enumerate(snake_case_      ):
           UpperCamelCase__         =    fill.copy().set_fill(snake_case_ ,				opacity=0.7      )
           target.move_to(snake_case_      )
           first_animations.append(GrowFromCenter(snake_case_ ,				run_time=1      )      )

           UpperCamelCase__         =    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(snake_case_ ,				run_time=1.5      )      )

       self.play(*snake_case_      )
       self.play(*snake_case_      )
       self.wait()












"""simple docstring"""





from collections import defaultdict
from math import ceil, sqrt







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE = 1_00_00_00 ,	SCREAMING_SNAKE_CASE = 10					)					->	int:
    """simple docstring"""

    UpperCamelCase__         =    defaultdict(SCREAMING_SNAKE_CASE					)

    for outer_width in range(3 ,	(t_limit // 4) + 2					):
        if outer_width * outer_width > t_limit:
            UpperCamelCase__         =    max(
                ceil(sqrt(outer_width * outer_width - t_limit					)					) ,	1					)
        else:
            UpperCamelCase__         =    1

        hole_width_lower_bound += (outer_width - hole_width_lower_bound) % 2

        for hole_width in range(SCREAMING_SNAKE_CASE ,	outer_width - 1 ,	2					):
            count[outer_width * outer_width - hole_width * hole_width] += 1

    return sum(1 for n in count.values() if 1 <= n <= 10					)


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




