





class      lowerCAmelCase							:
 def __init__(   self						:   List[str]    ,  UpperCAmelCase						:   Union[str, Any]    ,  UpperCAmelCase						:   List[str]=None    ,  UpperCAmelCase						:   int=None			)    ->			Optional[Any]:
     lowerCamelCase__					:   Optional[Any]      				=	data
     lowerCamelCase__					:   Optional[Any]      				=	previous
     lowerCamelCase__					:   str      				=	next_node
 def __str__(   self						:   Any			)    ->			str:
     return F"""{self.data}"""
 def   A_			(   self						:   List[str]			)    ->			int:
     return self.data
 def   A_			(   self						:   List[Any]			)    ->			List[str]:
     return self.next







 def   A_			(   self						:   int			)    ->			Any:
     return self.previous


class      lowerCAmelCase							:
 def __init__(   self						:   Any    ,  UpperCAmelCase						:   str			)    ->			Union[str, Any]:
     lowerCamelCase__					:   Tuple      				=	head
 def __iter__(   self						:   Optional[int]			)    ->			int:
     return self







 def   A_			(   self						:   str			)    ->			Optional[int]:
     if not self.current:
         raise StopIteration
     else:
         lowerCamelCase__					:   str      				=	self.current.get_data()
         lowerCamelCase__					:   List[str]      				=	self.current.get_next()
         return value


class      lowerCAmelCase							:
 def __init__(   self						:   int			)    ->			str:
     lowerCamelCase__					:   List[Any]      				=	None  # First node in list
     lowerCamelCase__					:   List[Any]      				=	None  # Last node in list
 def __str__(   self						:   Tuple			)    ->			List[Any]:
     lowerCamelCase__					:   Optional[Any]      				=	self.head
     lowerCamelCase__					:   Optional[Any]      				=	[]
     while current is not None:
         nodes.append(current.get_data()			)
         lowerCamelCase__					:   int      				=	current.get_next()
     return " ".join(str(snake_case_			) for node in nodes			)
 def __contains__(   self						:   Tuple    ,  UpperCAmelCase						:   List[str]			)    ->			Tuple:
     lowerCamelCase__					:   int      				=	self.head
     while current:
         if current.get_data() == value:
             return True
         lowerCamelCase__					:   Optional[Any]      				=	current.get_next()
     return False
 def __iter__(   self						:   Union[str, Any]			)    ->			Dict:
     return LinkedListIterator(self.head			)
 def   A_			(   self						:   Dict			)    ->			Union[str, Any]:
     if self.head:
         return self.head.get_data()
     return None
 def   A_			(   self						:   List[str]			)    ->			int:
     if self.tail:
         return self.tail.get_data()
     return None
 def   A_			(   self						:   List[Any]    ,  UpperCAmelCase						:   List[str]			)    ->			None:
     if self.head is None:
         lowerCamelCase__					:   Optional[Any]      				=	node
         lowerCamelCase__					:   int      				=	node
     else:
         self.insert_before_node(self.head    ,  snake_case_			)
 def   A_			(   self						:   List[str]    ,  UpperCAmelCase						:   Dict			)    ->			None:
     if self.head is None:
         self.set_head(snake_case_			)
     else:
         self.insert_after_node(self.tail    ,  snake_case_			)
 def   A_			(   self						:   Any    ,  UpperCAmelCase						:   Tuple			)    ->			None:
     lowerCamelCase__					:   List[str]      				=	Node(snake_case_			)
     if self.head is None:
         self.set_head(snake_case_			)
     else:
         self.set_tail(snake_case_			)
 def   A_			(   self						:   List[str]    ,  UpperCAmelCase						:   Dict    ,  UpperCAmelCase						:   Any			)    ->			None:
     lowerCamelCase__					:   Tuple      				=	node
     lowerCamelCase__					:   Any      				=	node.previous

     if node.get_previous() is None:
         lowerCamelCase__					:   List[str]      				=	node_to_insert
     else:
         lowerCamelCase__					:   Tuple      				=	node_to_insert

     lowerCamelCase__					:   Optional[Any]      				=	node_to_insert
 def   A_			(   self						:   Optional[int]    ,  UpperCAmelCase						:   int    ,  UpperCAmelCase						:   Dict			)    ->			None:
     lowerCamelCase__					:   Optional[int]      				=	node
     lowerCamelCase__					:   List[Any]      				=	node.next

     if node.get_next() is None:
         lowerCamelCase__					:   List[Any]      				=	node_to_insert
     else:
         lowerCamelCase__					:   Tuple      				=	node_to_insert

     lowerCamelCase__					:   Dict      				=	node_to_insert
 def   A_			(   self						:   List[str]    ,  UpperCAmelCase						:   Any    ,  UpperCAmelCase						:   List[Any]			)    ->			None:
     lowerCamelCase__					:   List[Any]      				=	1
     lowerCamelCase__					:   Tuple      				=	Node(snake_case_			)
     lowerCamelCase__					:   List[Any]      				=	self.head
     while node:
         if current_position == position:
             self.insert_before_node(snake_case_    ,  snake_case_			)
             return
         current_position += 1
         lowerCamelCase__					:   List[str]      				=	node.next
     self.insert_after_node(self.tail    ,  snake_case_			)
 def   A_			(   self						:   Tuple    ,  UpperCAmelCase						:   Optional[Any]			)    ->			Node:
     lowerCamelCase__					:   List[Any]      				=	self.head
     while node:
         if node.get_data() == item:
             return node
         lowerCamelCase__					:   Any      				=	node.get_next()
     raise Exception('Node not found'			)
 def   A_			(   self						:   int    ,  UpperCAmelCase						:   str			)    ->			Dict:
     if (node := self.get_node(snake_case_			)) is not None:
         if node == self.head:
             lowerCamelCase__					:   Dict      				=	self.head.get_next()

         if node == self.tail:
             lowerCamelCase__					:   List[str]      				=	self.tail.get_previous()

         self.remove_node_pointers(snake_case_			)
 @staticmethod
 def   A_			(   UpperCAmelCase						:   Tuple			)    ->			None:
     if node.get_next():
         lowerCamelCase__					:   str      				=	node.previous

     if node.get_previous():
         lowerCamelCase__					:   Union[str, Any]      				=	node.next

     lowerCamelCase__					:   Optional[Any]      				=	None
     lowerCamelCase__					:   str      				=	None







 def   A_			(   self						:   Union[str, Any]			)    ->			Dict:
     return self.head is None


def  SCREAMING_SNAKE_CASE   ( )    ->  None:
    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() = }""")





