





from __future__ import annotations

import math


class        __SCREAMING_SNAKE_CASE      :







       def __init__(				self					:     Any		, A					:     int      )       ->None:
          lowerCamelCase__       :						Optional[int]        =							size
          # approximate the overall size of segment tree with given value
          lowerCamelCase__       :						Dict        =							[0 for i in range(0		, 4 * size      )]
          # create array to store lazy update
          lowerCamelCase__       :						Dict        =							[0 for i in range(0		, 4 * size      )]
          lowerCamelCase__       :						Tuple        =							[0 for i in range(0		, 4 * size      )]  # flag for lazy update







       def 						__lowerCamelCase   (				self					:     List[str]		, A					:     int      )       ->int:
          return idx * 2







       def 						__lowerCamelCase   (				self					:     int		, A					:     int      )       ->int:
          return idx * 2 + 1







       def 						__lowerCamelCase   (				self					:     Dict		, A					:     int		, A					:     int		, A					:     int		, A					:     list[int]      )       ->None:
          if left_element == right_element:
             lowerCamelCase__       :						int        =							a[left_element - 1]
          else:
             lowerCamelCase__       :						List[str]        =							(left_element + right_element) // 2
             self.build(self.left(A      )		, A		, A		, A      )
             self.build(self.right(A      )		, mid + 1		, A		, A      )
             lowerCamelCase__       :						List[Any]        =							max(
                 self.segment_tree[self.left(A      )]		, self.segment_tree[self.right(A      )]      )







       def 						__lowerCamelCase   (				self					:     List[str]		, A					:     int		, A					:     int		, A					:     int		, A					:     int		, A					:     int		, A					:     int      )       ->bool:
          if self.flag[idx] is True:
             lowerCamelCase__       :						Any        =							self.lazy[idx]
             lowerCamelCase__       :						Tuple        =							False
             if left_element != right_element:
                lowerCamelCase__       :						int        =							self.lazy[idx]
                lowerCamelCase__       :						Optional[Any]        =							self.lazy[idx]
                lowerCamelCase__       :						Optional[int]        =							True
                lowerCamelCase__       :						Union[str, Any]        =							True

          if right_element < a or left_element > b:
             return True
          if left_element >= a and right_element <= b:
             lowerCamelCase__       :						Optional[int]        =							val
             if left_element != right_element:
                lowerCamelCase__       :						str        =							val
                lowerCamelCase__       :						Tuple        =							val
                lowerCamelCase__       :						Optional[int]        =							True
                lowerCamelCase__       :						List[Any]        =							True
             return True
          lowerCamelCase__       :						Any        =							(left_element + right_element) // 2
          self.update(self.left(A      )		, A		, A		, A		, A		, A      )
          self.update(self.right(A      )		, mid + 1		, A		, A		, A		, A      )
          lowerCamelCase__       :						int        =							max(
              self.segment_tree[self.left(A      )]		, self.segment_tree[self.right(A      )]      )
          return True







       def 						__lowerCamelCase   (				self					:     Union[str, Any]		, A					:     int		, A					:     int		, A					:     int		, A					:     int		, A					:     int      )       ->int | float:
          if self.flag[idx] is True:
             lowerCamelCase__       :						Union[str, Any]        =							self.lazy[idx]
             lowerCamelCase__       :						Tuple        =							False
             if left_element != right_element:
                lowerCamelCase__       :						Optional[int]        =							self.lazy[idx]
                lowerCamelCase__       :						Tuple        =							self.lazy[idx]
                lowerCamelCase__       :						List[str]        =							True
                lowerCamelCase__       :						List[str]        =							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]
          lowerCamelCase__       :						List[str]        =							(left_element + right_element) // 2
          lowerCamelCase__       :						Any        =							self.query(self.left(A      )		, A		, A		, A		, A      )
          lowerCamelCase__       :						Optional[int]        =							self.query(self.right(A      )		, mid + 1		, A		, A		, A      )
          return max(A		, A      )







       def __str__(				self					:     Optional[Any]      )       ->str:
          return str([self.query(1		, 1		, self.size		, A		, A      ) for i in range(1		, self.size + 1      )]      )


if __name__ == "__main__":
       _A :   List[Any]  			=  [1, 2, -4, 7, 3, -5, 6, 11, -20, 9, 14, 15, 5, 2, -8]
       _A :   Optional[int]  			=  15
       _A :   Any  			=  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, 1_11)
       print(segt.query(1, 1, size, 1, 15))
       segt.update(1, 1, size, 7, 8, 2_35)
       print(segt)










from math import ceil, sqrt



def 	_a						(   UpperCAmelCase = 1000000					)    ->    int:







   """simple docstring"""
   lowerCamelCase__       :						Any        =							0

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

      answer += (outer_width - hole_width_lower_bound - 2) // 2 + 1

   return answer


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



