





import math





def 				__lowerCAmelCase(       _SCREAMING_SNAKE_CASE				)							-> str:




    """simple docstring"""




    _A     =							0
    _A     =							0
    while num > 0:
        _A     =							num % 8
        _A     =							octal + (remainder * math.floor(math.pow(10							,     _SCREAMING_SNAKE_CASE				)				))
        counter += 1
        _A     =							math.floor(num / 8				)  # basically /= 8 without remainder if any
        # This formatting removes trailing '.0' from `octal`.
    return F"0o{int(_SCREAMING_SNAKE_CASE				)}"





def 				__lowerCAmelCase(       )							-> None:




    """simple docstring"""




    print('\n2 in octal is:'				)
    print(decimal_to_octal(2				)				)  # = 2
    print('\n8 in octal is:'				)
    print(decimal_to_octal(8				)				)  # = 10
    print('\n65 in octal is:'				)
    print(decimal_to_octal(65				)				)  # = 101
    print('\n216 in octal is:'				)
    print(decimal_to_octal(216				)				)  # = 330
    print('\n512 in octal is:'				)
    print(decimal_to_octal(512				)				)  # = 1000
    print('\n'				)


if __name__ == "__main__":
 main()






"""simple docstring"""




from __future__ import annotations

from typing import Any

class    a_   :




					def __init__(						self    :  Union[str, Any]	,    snake_case__    :  int = 6  ):
							lowerCAmelCase__   = None
							lowerCAmelCase__   = None
							self.create_linked_list(snake_case__  )




					def     _SCREAMING_SNAKE_CASE    (						self    :  Tuple	,    snake_case__    :  int  ):
							lowerCAmelCase__   = Node()
							lowerCAmelCase__   = current_node
							lowerCAmelCase__   = current_node
							lowerCAmelCase__   = current_node
							for _ in range(1	,    snake_case__  ):
									lowerCAmelCase__   = Node()
									lowerCAmelCase__   = current_node
									lowerCAmelCase__   = previous_node
									lowerCAmelCase__   = current_node
							lowerCAmelCase__   = self.front
							lowerCAmelCase__   = previous_node




					def     _SCREAMING_SNAKE_CASE    (						self    :  Any  ):
							return (
							    self.front == self.rear
							    and self.front is not None
							    and self.front.data is None
							)




					def     _SCREAMING_SNAKE_CASE    (						self    :  Any  ):
							self.check_can_perform_operation()
							return self.front.data if self.front else None




					def     _SCREAMING_SNAKE_CASE    (						self    :  Dict	,    snake_case__    :  Any  ):
							if self.rear is None:
									return

							self.check_is_full()
							if not self.is_empty():
									lowerCAmelCase__   = self.rear.next
							if self.rear:
									lowerCAmelCase__   = data




					def     _SCREAMING_SNAKE_CASE    (						self    :  Any  ):
							self.check_can_perform_operation()
							if self.rear is None or self.front is None:
									return None
							if self.front == self.rear:
									lowerCAmelCase__   = self.front.data
									lowerCAmelCase__   = None
									return data

							lowerCAmelCase__   = self.front
							lowerCAmelCase__   = old_front.next
							lowerCAmelCase__   = old_front.data
							lowerCAmelCase__   = None
							return data




					def     _SCREAMING_SNAKE_CASE    (						self    :  Union[str, Any]  ):
							if self.is_empty():
									raise Exception("""Empty Queue"""  )




					def     _SCREAMING_SNAKE_CASE    (						self    :  Optional[Any]  ):
							if self.rear and self.rear.next == self.front:
									raise Exception("""Full Queue"""  )

class    a_   :




					def __init__(						self    :  Union[str, Any]  ):
							lowerCAmelCase__   = None
							lowerCAmelCase__   = None
							lowerCAmelCase__   = None


if __name__ == "__main__":
			import doctest

			doctest.testmod()




