



'''simple docstring'''




from math import ceil, sqrt


def 				lowerCAmelCase_   (	_lowerCamelCase:   int = 1_00_00_00					):
		__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		0

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




'''simple docstring'''




from collections.abc import Iterable
from typing import Any






class 						_UpperCamelCase  :


			'''simple docstring'''

			def __init__(							self     : Optional[int]							,     lowerCAmelCase__     : int | None = None						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		value
					__SCREAMING_SNAKE_CASE       :		Node | None           =		None  # Added in order to delete a node easier
					__SCREAMING_SNAKE_CASE       :		Node | None           =		None
					__SCREAMING_SNAKE_CASE       :		Node | None           =		None



			def __repr__(							self     : Optional[Any]						):





					"""simple docstring"""






					from pprint import pformat

					if self.left is None and self.right is None:
							return str(self.value						)
					return pformat({F"{self.value}": (self.left, self.right)}							,     indent=1						)






class 						_UpperCamelCase  :


			'''simple docstring'''

			def __init__(							self     : Optional[int]							,     lowerCAmelCase__     : Node | None = None						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		str           =		root

			def __str__(							self     : Union[str, Any]						):





					"""simple docstring"""






					return str(self.root						)

			def UpperCamelCase__					(							self     : Dict							,     lowerCAmelCase__     : Node							,     lowerCAmelCase__     : Node | None						):





					"""simple docstring"""






					if new_children is not None:  # reset its kids
							__SCREAMING_SNAKE_CASE       :		List[str]           =		node.parent
					if node.parent is not None:  # reset its parent
							if self.is_right(lowerCAmelCase__						):  # If it is the right children
									__SCREAMING_SNAKE_CASE       :		Any           =		new_children
							else:
									__SCREAMING_SNAKE_CASE       :		int           =		new_children
					else:
							__SCREAMING_SNAKE_CASE       :		int           =		new_children

			def UpperCamelCase__					(							self     : str							,     lowerCAmelCase__     : Node						):





					"""simple docstring"""






					if node.parent and node.parent.right:
							return node == node.parent.right
					return False

			def UpperCamelCase__					(							self     : List[Any]						):





					"""simple docstring"""






					return self.root is None

			def UpperCamelCase__					(							self     : Optional[Any]							,     lowerCAmelCase__     : str						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		Node(lowerCAmelCase__						)  # create a new Node
					if self.empty():  # if Tree is empty
							__SCREAMING_SNAKE_CASE       :		Optional[int]           =		new_node  # set its root
					else:  # Tree is not empty
							__SCREAMING_SNAKE_CASE       :		Optional[int]           =		self.root  # from root
							if parent_node is None:
									return
							while True:  # While we don't get to a leaf
									if value < parent_node.value:  # We go left
											if parent_node.left is None:
													__SCREAMING_SNAKE_CASE       :		List[str]           =		new_node  # We insert the new node in a leaf
													break
											else:
													__SCREAMING_SNAKE_CASE       :		Any           =		parent_node.left
									else:
											if parent_node.right is None:
													__SCREAMING_SNAKE_CASE       :		Tuple           =		new_node
													break
											else:
													__SCREAMING_SNAKE_CASE       :		List[str]           =		parent_node.right
							__SCREAMING_SNAKE_CASE       :		Tuple           =		parent_node

			def UpperCamelCase__					(							self     : str							,     *lowerCAmelCase__     : List[Any]						):





					"""simple docstring"""






					for value in values:
							self.__insert(lowerCAmelCase__						)

			def UpperCamelCase__					(							self     : List[str]							,     lowerCAmelCase__     : Union[str, Any]						):





					"""simple docstring"""






					if self.empty():
							raise IndexError("""Warning: Tree is empty! please use another."""						)
					else:
							__SCREAMING_SNAKE_CASE       :		List[Any]           =		self.root
							# use lazy evaluation here to avoid NoneType Attribute error
							while node is not None and node.value is not value:
									__SCREAMING_SNAKE_CASE       :		Any           =		node.left if value < node.value else node.right
							return node

			def UpperCamelCase__					(							self     : List[Any]							,     lowerCAmelCase__     : Node | None = None						):





					"""simple docstring"""






					if node is None:
							if self.root is None:
									return None
							__SCREAMING_SNAKE_CASE       :		Optional[Any]           =		self.root

					if not self.empty():
							while node.right is not None:
									__SCREAMING_SNAKE_CASE       :		Tuple           =		node.right
					return node

			def UpperCamelCase__					(							self     : Dict							,     lowerCAmelCase__     : Node | None = None						):





					"""simple docstring"""






					if node is None:
							__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		self.root
					if self.root is None:
							return None
					if not self.empty():
							__SCREAMING_SNAKE_CASE       :		Optional[Any]           =		self.root
							while node.left is not None:
									__SCREAMING_SNAKE_CASE       :		Any           =		node.left
					return node

			def UpperCamelCase__					(							self     : str							,     lowerCAmelCase__     : int						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		List[str]           =		self.search(lowerCAmelCase__						)  # Look for the node with that label
					if node is not None:
							if node.left is None and node.right is None:  # If it has no children
									self.__reassign_nodes(lowerCAmelCase__							,     lowerCAmelCase__						)
							elif node.left is None:  # Has only right children
									self.__reassign_nodes(lowerCAmelCase__							,     node.right						)
							elif node.right is None:  # Has only left children
									self.__reassign_nodes(lowerCAmelCase__							,     node.left						)
							else:
									__SCREAMING_SNAKE_CASE       :		Tuple           =		self.get_max(
									    node.left						)  # Gets the max value of the left branch
									self.remove(tmp_node.value						)  # type: ignore
									__SCREAMING_SNAKE_CASE       :		Optional[Any]           =		(
									    tmp_node.value  # type: ignore
									)  # Assigns the value to the node to delete and keep tree structure

			def UpperCamelCase__					(							self     : Tuple							,     lowerCAmelCase__     : Node | None						):





					"""simple docstring"""






					if node is not None:
							yield node  # Preorder Traversal
							yield from self.preorder_traverse(node.left						)
							yield from self.preorder_traverse(node.right						)

			def UpperCamelCase__					(							self     : Optional[int]							,     lowerCAmelCase__     : Optional[Any]=None						):





					"""simple docstring"""






					if traversal_function is None:
							return self.preorder_traverse(self.root						)
					else:
							return traversal_function(self.root						)

			def UpperCamelCase__					(							self     : str							,     lowerCAmelCase__     : list							,     lowerCAmelCase__     : Node | None						):





					"""simple docstring"""






					if node:
							self.inorder(lowerCAmelCase__							,     node.left						)
							arr.append(node.value						)
							self.inorder(lowerCAmelCase__							,     node.right						)



			def UpperCamelCase__					(							self     : int							,     lowerCAmelCase__     : int							,     lowerCAmelCase__     : Node						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		list[int]           =		[]
					self.inorder(lowerCAmelCase__							,     lowerCAmelCase__						)  # append all values to list using inorder traversal
					return arr[k - 1]


def 				lowerCAmelCase_   (	_lowerCamelCase:   Node | None					):
		__SCREAMING_SNAKE_CASE       :		Optional[Any]           =		[]
		if curr_node is not None:
				__SCREAMING_SNAKE_CASE       :		Optional[int]           =		postorder(curr_node.left					) + postorder(curr_node.right					) + [curr_node]
		return node_list


def 				lowerCAmelCase_   (	):
		__SCREAMING_SNAKE_CASE       :		str           =		(8, 3, 6, 1, 10, 14, 13, 4, 7)
		__SCREAMING_SNAKE_CASE       :		Dict           =		BinarySearchTree()
		for i in testlist:
				t.insert(_lowerCamelCase					)

		# Prints all the elements of the list in order traversal
		print(_lowerCamelCase					)

		if t.search(6					) is not None:
				print("""The value 6 exists"""					)
		else:
				print("""The value 6 doesn't exist"""					)

		if t.search(-1					) is not None:
				print("""The value -1 exists"""					)
		else:
				print("""The value -1 doesn't exist"""					)

		if not t.empty():
				print("""Max Value: """       ,      t.get_max().value					)  # type: ignore
				print("""Min Value: """       ,      t.get_min().value					)  # type: ignore

		for i in testlist:
				t.remove(_lowerCamelCase					)
				print(_lowerCamelCase					)


if __name__ == "__main__":
						import doctest

						doctest.testmod(verbose=True)