





class      lowerCAmelCase							:
 def __init__(   self						:   str    ,  UpperCAmelCase						:   Optional[Any]    ,  UpperCAmelCase						:   str    ,  UpperCAmelCase						:   Dict			)    ->			Optional[int]:
     lowerCamelCase__					:   Optional[int]      				=	name
     lowerCamelCase__					:   Tuple      				=	value
     lowerCamelCase__					:   Any      				=	weight
 def __repr__(   self						:   Dict			)    ->			str:
     return F"""{self.__class__.__name__}({self.name}, {self.value}, {self.weight})"""
 def   A_			(   self						:   str			)    ->			Optional[Any]:
     return self.value
 def   A_			(   self						:   str			)    ->			Dict:
     return self.name
 def   A_			(   self						:   Any			)    ->			Tuple:
     return self.weight







 def   A_			(   self						:   int			)    ->			Optional[Any]:
     return self.value / self.weight


def  SCREAMING_SNAKE_CASE   ( _UpperCAmelCase		,			_UpperCAmelCase		,			_UpperCAmelCase				)    ->  List[Any]:
    lowerCamelCase__					:   Tuple      				=	[]
    for i in range(len(_UpperCAmelCase				)				):
        menu.append(Things(name[i]		,			value[i]		,			weight[i]				)				)
    return menu


def  SCREAMING_SNAKE_CASE   ( _UpperCAmelCase		,			_UpperCAmelCase		,			_UpperCAmelCase				)    ->  str:
    lowerCamelCase__					:   Union[str, Any]      				=	sorted(_UpperCAmelCase		,			key=_UpperCAmelCase		,			reverse=_UpperCAmelCase				)
    lowerCamelCase__					:   Any      				=	[]
    lowerCamelCase__				,							lowerCamelCase__					:   int      				=	0.0, 0.0
    for i in range(len(_UpperCAmelCase				)				):
        if (total_cost + items_copy[i].get_weight()) <= max_cost:
            result.append(items_copy[i]				)
            total_cost += items_copy[i].get_weight()
            total_value += items_copy[i].get_value()
    return (result, total_value)


def  SCREAMING_SNAKE_CASE   ( )    ->  Tuple:
    pass


if __name__ == "__main__":
    import doctest

    doctest.testmod()












from collections import defaultdict
from math import ceil, sqrt


def  SCREAMING_SNAKE_CASE   ( _UpperCAmelCase = 100_0000		,			_UpperCAmelCase = 10				)    ->  int:
    lowerCamelCase__					:   defaultdict      				=	defaultdict(_UpperCAmelCase				)

    for outer_width in range(3		,			(t_limit // 4) + 2				):
        if outer_width * outer_width > t_limit:
            lowerCamelCase__					:   List[str]      				=	max(
                ceil(sqrt(outer_width * outer_width - t_limit				)				)		,			1				)
        else:
            lowerCamelCase__					:   int      				=	1

        hole_width_lower_bound += (outer_width - hole_width_lower_bound) % 2

        for hole_width in range(_UpperCAmelCase		,			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() = }""")





