





from __future__ import annotations

from typing import Any
class SCREAMING_SNAKE_CASE_  :






						def __init__(					self					:					List[str]						,      _A					:					int = 6		)							->			List[Any]:







							"""simple docstring"""


							snake_case_						:	Dict      =		None
							snake_case_						:	List[str]      =		None
							self.create_linked_list(UpperCamelCase__		)






						def UpperCAmelCase_ (					self					:					List[Any]						,      _A					:					int		)							->			Optional[int]:







							"""simple docstring"""


							snake_case_						:	Optional[Any]      =		Node()
							snake_case_						:	Optional[int]      =		current_node
							snake_case_						:	Tuple      =		current_node
							snake_case_						:	str      =		current_node
							for _ in range(1						,      UpperCamelCase__		):
								snake_case_						:	Optional[int]      =		Node()
								snake_case_						:	Union[str, Any]      =		current_node
								snake_case_						:	Dict      =		previous_node
								snake_case_						:	Optional[Any]      =		current_node
							snake_case_						:	Optional[int]      =		self.front
							snake_case_						:	List[Any]      =		previous_node






						def UpperCAmelCase_ (					self					:					str		)							->			Optional[int]:







							"""simple docstring"""


							return (
							    self.front == self.rear
							    and self.front is not None
							    and self.front.data is None
							)






						def UpperCAmelCase_ (					self					:					List[str]		)							->			List[str]:







							"""simple docstring"""


							self.check_can_perform_operation()
							return self.front.data if self.front else None






						def UpperCAmelCase_ (					self					:					str						,      _A					:					Any		)							->			str:







							"""simple docstring"""


							if self.rear is None:
								return

							self.check_is_full()
							if not self.is_empty():
								snake_case_						:	Optional[int]      =		self.rear.next
							if self.rear:
								snake_case_						:	Tuple      =		data






						def UpperCAmelCase_ (					self					:					Dict		)							->			int:







							"""simple docstring"""


							self.check_can_perform_operation()
							if self.rear is None or self.front is None:
								return None
							if self.front == self.rear:
								snake_case_						:	List[Any]      =		self.front.data
								snake_case_						:	List[Any]      =		None
								return data

							snake_case_						:	Tuple      =		self.front
							snake_case_						:	Optional[Any]      =		old_front.next
							snake_case_						:	List[Any]      =		old_front.data
							snake_case_						:	Union[str, Any]      =		None
							return data






						def UpperCAmelCase_ (					self					:					Any		)							->			str:







							"""simple docstring"""


							if self.is_empty():
								raise Exception('Empty Queue'		)






						def UpperCAmelCase_ (					self					:					Tuple		)							->			List[Any]:







							"""simple docstring"""


							if self.rear and self.rear.next == self.front:
								raise Exception('Full Queue'		)
class SCREAMING_SNAKE_CASE_  :






						def __init__(					self					:					Any		)							->			List[Any]:







							"""simple docstring"""


							snake_case_						:	Any      =		None
							snake_case_						:	Optional[int]      =		None
							snake_case_						:	int      =		None


if __name__ == "__main__":
						import doctest

						doctest.testmod()






'''simple docstring'''


def 				__lowerCamelCase				(   A__ = 10**9    )       ->	int:






   """simple docstring"""
   UpperCamelCase					=  1
   UpperCamelCase					=  2

   UpperCamelCase					=  0
   UpperCamelCase					=  0
   UpperCamelCase					=  0
   while perimeter <= max_perimeter:
      perimeters_sum += perimeter

      prev_value += 2 * value
      value += prev_value

      UpperCamelCase					=  2 * value + 2 if i % 2 == 0 else 2 * value - 2
      i += 1

   return perimeters_sum


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

