






import math







def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase    )				->			list[int]:







     if not isinstance(__lowerCAmelCase      ,					__lowerCAmelCase    ):
          UpperCamelCase__    :     Union[str, Any]        =						f'Input value of [number={number}] must be an integer'
          raise TypeError(__lowerCAmelCase    )
     if number < 1:
          UpperCamelCase__    :     Optional[int]        =						f'Input value of [number={number}] must be a positive integer'
          raise ValueError(__lowerCAmelCase    )
     UpperCamelCase__    :     List[Any]        =						[number]
     while number != 1:
          if number % 2 == 0:
               UpperCamelCase__    :     int        =						math.floor(math.sqrt(__lowerCAmelCase    )    )
          else:
               UpperCamelCase__    :     int        =						math.floor(
                   math.sqrt(__lowerCAmelCase    ) * math.sqrt(__lowerCAmelCase    ) * math.sqrt(__lowerCAmelCase    )    )
          sequence.append(__lowerCAmelCase    )
     return sequence


if __name__ == "__main__":
 import doctest

 doctest.testmod()







from __future__ import annotations

from collections.abc import Iterator
from typing import Any





class     __a						:







 def __init__(	self      :     str							,     SCREAMING_SNAKE_CASE      :     Any		):


      '''simple docstring'''






      UpperCamelCase__    :     Any        =						data
      UpperCamelCase__    :     Node | None        =						None







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


      '''simple docstring'''






      return F'{self.data}'







class     __a						:







 def __init__(	self      :     Optional[int]		):


      '''simple docstring'''






      UpperCamelCase__    :     Node | None        =						None
      UpperCamelCase__    :     Node | None        =						None







 def __iter__(	self      :     str		):


      '''simple docstring'''






      UpperCamelCase__    :     int        =						self.front
      while node:
           yield node.data
           UpperCamelCase__    :     Any        =						node.next







 def __len__(	self      :     Tuple		):


      '''simple docstring'''






      return len(tuple(iter(self		)		)		)







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


      '''simple docstring'''






      return " <- ".join(str(SCREAMING_SNAKE_CASE		) for item in self		)







 def       __lowercase      (	self      :     List[str]		):


      '''simple docstring'''






      return len(self		) == 0







 def       __lowercase      (	self      :     Union[str, Any]							,     SCREAMING_SNAKE_CASE      :     Any		):


      '''simple docstring'''






      UpperCamelCase__    :     int        =						Node(SCREAMING_SNAKE_CASE		)
      if self.is_empty():
           UpperCamelCase__    :     int        =						node
      else:
           assert isinstance(self.rear							,     SCREAMING_SNAKE_CASE		)
           UpperCamelCase__    :     Dict        =						node
           UpperCamelCase__    :     str        =						node







 def       __lowercase      (	self      :     Dict		):


      '''simple docstring'''






      if self.is_empty():
           raise IndexError("dequeue from empty queue"		)
      assert isinstance(self.front							,     SCREAMING_SNAKE_CASE		)
      UpperCamelCase__    :     Optional[int]        =						self.front
      UpperCamelCase__    :     List[str]        =						self.front.next
      if self.front is None:
           UpperCamelCase__    :     List[Any]        =						None
      return node.data







 def       __lowercase      (	self      :     str		):


      '''simple docstring'''






      UpperCamelCase__    :     Optional[int]        =						None


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

 testmod()