






"""simple docstring"""


from __future__ import annotations

import math


class 					snake_case		:


   '''simple docstring'''

   def __init__(	self :     Tuple,       _lowerCamelCase :     int  ):

     '''simple docstring'''
     __A									= size
     # approximate the overall size of segment tree with given value
     __A									= [0 for i in range(0,       4 * size  )]
     # create array to store lazy update
     __A									= [0 for i in range(0,       4 * size  )]
     __A									= [0 for i in range(0,       4 * size  )]  # flag for lazy update


   def 				_SCREAMING_SNAKE_CASE				(	self :     Optional[int],       _lowerCamelCase :     int  ):

     '''simple docstring'''
     return idx * 2


   def 				_SCREAMING_SNAKE_CASE				(	self :     int,       _lowerCamelCase :     int  ):

     '''simple docstring'''
     return idx * 2 + 1


   def 				_SCREAMING_SNAKE_CASE				(	self :     Any,       _lowerCamelCase :     int,       _lowerCamelCase :     int,       _lowerCamelCase :     int,       _lowerCamelCase :     list[int]  ):

     '''simple docstring'''
     if left_element == right_element:
       __A									= a[left_element - 1]
     else:
       __A									= (left_element + right_element) // 2
       self.build(self.left(_lowerCamelCase  ),       _lowerCamelCase,       _lowerCamelCase,       _lowerCamelCase  )
       self.build(self.right(_lowerCamelCase  ),       mid + 1,       _lowerCamelCase,       _lowerCamelCase  )
       __A									= max(
           self.segment_tree[self.left(_lowerCamelCase  )],       self.segment_tree[self.right(_lowerCamelCase  )]  )


   def 				_SCREAMING_SNAKE_CASE				(	self :     List[Any],       _lowerCamelCase :     int,       _lowerCamelCase :     int,       _lowerCamelCase :     int,       _lowerCamelCase :     int,       _lowerCamelCase :     int,       _lowerCamelCase :     int  ):

     '''simple docstring'''
     if self.flag[idx] is True:
       __A									= self.lazy[idx]
       __A									= False
       if left_element != right_element:
         __A									= self.lazy[idx]
         __A									= self.lazy[idx]
         __A									= True
         __A									= True

     if right_element < a or left_element > b:
       return True
     if left_element >= a and right_element <= b:
       __A									= val
       if left_element != right_element:
         __A									= val
         __A									= val
         __A									= True
         __A									= True
       return True
     __A									= (left_element + right_element) // 2
     self.update(self.left(_lowerCamelCase  ),       _lowerCamelCase,       _lowerCamelCase,       _lowerCamelCase,       _lowerCamelCase,       _lowerCamelCase  )
     self.update(self.right(_lowerCamelCase  ),       mid + 1,       _lowerCamelCase,       _lowerCamelCase,       _lowerCamelCase,       _lowerCamelCase  )
     __A									= max(
         self.segment_tree[self.left(_lowerCamelCase  )],       self.segment_tree[self.right(_lowerCamelCase  )]  )
     return True


   def 				_SCREAMING_SNAKE_CASE				(	self :     Dict,       _lowerCamelCase :     int,       _lowerCamelCase :     int,       _lowerCamelCase :     int,       _lowerCamelCase :     int,       _lowerCamelCase :     int  ):

     '''simple docstring'''
     if self.flag[idx] is True:
       __A									= self.lazy[idx]
       __A									= False
       if left_element != right_element:
         __A									= self.lazy[idx]
         __A									= self.lazy[idx]
         __A									= True
         __A									= True
     if right_element < a or left_element > b:
       return -math.inf
     if left_element >= a and right_element <= b:
       return self.segment_tree[idx]
     __A									= (left_element + right_element) // 2
     __A									= self.query(self.left(_lowerCamelCase  ),       _lowerCamelCase,       _lowerCamelCase,       _lowerCamelCase,       _lowerCamelCase  )
     __A									= self.query(self.right(_lowerCamelCase  ),       mid + 1,       _lowerCamelCase,       _lowerCamelCase,       _lowerCamelCase  )
     return max(_lowerCamelCase,       _lowerCamelCase  )






   def __str__(	self :     Dict  ):

     '''simple docstring'''
     return str([self.query(1,       1,       self.size,       _lowerCamelCase,       _lowerCamelCase  ) for i in range(1,       self.size + 1  )]  )


if __name__ == "__main__":
       lowercase_				     =     [1, 2, -4, 7, 3, -5, 6, 11, -20, 9, 14, 15, 5, 2, -8]
       lowercase_				     =     15
       lowercase_				     =     SegmentTree(size)
       segt.build(1, 1, size, A)
       print(segt.query(1, 1, size, 4, 6))
       print(segt.query(1, 1, size, 7, 11))
       print(segt.query(1, 1, size, 7, 12))
       segt.update(1, 1, size, 1, 3, 111)
       print(segt.query(1, 1, size, 1, 15))
       segt.update(1, 1, size, 7, 8, 235)
       print(segt)












"""simple docstring"""


from collections import defaultdict
from math import ceil, sqrt



def 					lowerCAmelCase				(    __UpperCamelCase = 1_0_0_0_0_0_0		,       __UpperCamelCase = 1_0 ):




  """simple docstring"""







  __A									= defaultdict(__UpperCamelCase )

  for outer_width in range(3		,       (t_limit // 4) + 2 ):
    if outer_width * outer_width > t_limit:
      __A									= max(
          ceil(sqrt(outer_width * outer_width - t_limit ) )		,       1 )
    else:
      __A									= 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 <= 1_0 )


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




