






"""simple docstring"""





from copy import deepcopy
class    __lowerCamelCase    :

   def __init__(					self ,				snake_case_ = None ,				snake_case_ = None      )		->       None:

        if arr is None and size is not None:
             UpperCamelCase__         =    size
             UpperCamelCase__         =    [0] * size
        elif arr is not None:
             self.init(snake_case_      )
        else:
             raise ValueError('Either arr or size must be specified'      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_      )		->       None:
        UpperCamelCase__         =    len(snake_case_      )
        UpperCamelCase__         =    deepcopy(snake_case_      )
        for i in range(1 ,				self.size      ):
             UpperCamelCase__         =    self.next_(snake_case_      )
             if j < self.size:
                  self.tree[j] += self.tree[i]

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       list[int]:
        UpperCamelCase__         =    self.tree[:]
        for i in range(self.size - 1 ,				0 ,				-1      ):
             UpperCamelCase__         =    self.next_(snake_case_      )
             if j < self.size:
                  arr[j] -= arr[i]
        return arr

   @staticmethod
   def 						SCREAMING_SNAKE_CASE__ (					snake_case_      )		->       int:
        return index + (index & (-index))

   @staticmethod
   def 						SCREAMING_SNAKE_CASE__ (					snake_case_      )		->       int:
        return index - (index & (-index))

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_      )		->       None:
        if index == 0:
             self.tree[0] += value
             return
        while index < self.size:
             self.tree[index] += value
             UpperCamelCase__         =    self.next_(snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_      )		->       None:
        self.add(snake_case_ ,				value - self.get(snake_case_      )      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_      )		->       int:
        if right == 0:
             return 0
        UpperCamelCase__         =    self.tree[0]
        right -= 1  # make right inclusive
        while right > 0:
             result += self.tree[right]
             UpperCamelCase__         =    self.prev(snake_case_      )
        return result

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_      )		->       int:
        return self.prefix(snake_case_      ) - self.prefix(snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_      )		->       int:
        return self.query(snake_case_ ,				index + 1      )







   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_      )		->       int:
        value -= self.tree[0]
        if value < 0:
             return -1

        UpperCamelCase__         =    1  # Largest power of 2 <= size
        while j * 2 < self.size:
             j *= 2

        UpperCamelCase__         =    0

        while j > 0:
             if i + j < self.size and self.tree[i + j] <= value:
                  value -= self.tree[i + j]
                  i += j
             j //= 2
        return i


if __name__ == "__main__":
  import doctest

  doctest.testmod()












"""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() = }""")




