



from collections.abc import Iterable
from typing import Generic, TypeVar

A__								=						TypeVar('''_T''')


class       a							(			Generic[_T]				):



		def __init__(     self     :Tuple   ,__lowercase     :Iterable[_T] | None = None  ):
						snake_case__	:      list[_T]     		=	list(iterable or []  )
						snake_case__	:      list[_T]     		=	[]



		def __len__(     self     :Union[str, Any]  ):
						return len(self._stacka  ) + len(self._stacka  )



		def __repr__(     self     :Tuple  ):
						return F"""Queue({tuple(self._stacka[::-1] + self._stacka  )})"""



		def 	__lowerCamelCase			(     self     :Union[str, Any]   ,__lowercase     :_T  ):
						self._stacka.append(__lowercase  )






		def 	__lowerCamelCase			(     self     :Optional[int]  ):
						snake_case__	:      Union[str, Any]     		=	self._stacka.pop
						snake_case__	:      Union[str, Any]     		=	self._stacka.append

						if not self._stacka:
										while self._stacka:
														stacka_append(stacka_pop()  )

						if not self._stacka:
										raise IndexError('''Queue is empty'''  )
						return self._stacka.pop()


if __name__ == "__main__":
				from doctest import testmod

				testmod()






from math import ceil, sqrt



def 			_lowerCAmelCase       (					__lowerCAmelCase = 1000000      )   ->					int:


				"""simple docstring"""

				snake_case__	:      Dict     		=	0

				for outer_width in range(3  ,  (limit // 4) + 2      ):
								if outer_width**2 > limit:
												snake_case__	:      Any     		=	max(ceil(sqrt(outer_width**2 - limit      )      )  ,  1      )
								else:
												snake_case__	:      int     		=	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() = }""")

