"""simple docstring"""






def SCREAMING_SNAKE_CASE__    (     __UpperCAmelCase				)						->						Optional[int]:
   lowercase__:     str      =   [7_0_1, 3_0_1, 1_3_2, 5_7, 2_3, 1_0, 4, 1]
   for gap in gaps:
      for i in range(__UpperCAmelCase ,					len(__UpperCAmelCase				)				):
         lowercase__:     Any      =   collection[i]
         lowercase__:     Tuple      =   i
         while j >= gap and collection[j - gap] > insert_value:
            lowercase__:     List[str]      =   collection[j - gap]
            j -= gap
         if j != i:
            lowercase__:     List[str]      =   insert_value
   return collection


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

       testmod()
       __A         =				input("Enter numbers separated by a comma:\n").strip()
       __A         =				[int(item) for item in user_input.split(",")]
       print(shell_sort(unsorted))

"""simple docstring"""






from __future__ import annotations

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

__A         =				TypeVar("T", bound=bool)


class 					UpperCAmelCase		(Generic[T]						):



    """simple docstring"""

    def __init__(     self					,    _UpperCAmelCase							):
       lowercase__:     T      =   value
       lowercase__:     RandomizedHeapNode[T] | None      =   None
       lowercase__:     RandomizedHeapNode[T] | None      =   None






    @property
    def _snake_case    (     self							):
       return self._value






    @staticmethod
    def _snake_case    (     _UpperCAmelCase					,    _UpperCAmelCase							):
       if not roota:
          return roota

       if not roota:
          return roota

       if roota.value > roota.value:
          lowercase__,				lowercase__:     List[str]      =   roota, roota

       if random.choice([True, False]							):
          lowercase__,				lowercase__:     Any      =   roota.right, roota.left

       lowercase__:     Optional[int]      =   RandomizedHeapNode.merge(roota.left					,    _UpperCAmelCase							)

       return roota



class 					UpperCAmelCase		(Generic[T]						):



    """simple docstring"""

    def __init__(     self					,    _UpperCAmelCase = ()							):
       lowercase__:     RandomizedHeapNode[T] | None      =   None

       if data:
          for item in data:
             self.insert(_UpperCAmelCase							)






    def _snake_case    (     self					,    _UpperCAmelCase							):
       lowercase__:     Any      =   RandomizedHeapNode.merge(self._root					,    RandomizedHeapNode(_UpperCAmelCase							)							)






    def _snake_case    (     self							):
       lowercase__:     Union[str, Any]      =   self.top()

       if self._root is None:
          return None

       lowercase__:     int      =   RandomizedHeapNode.merge(self._root.left					,    self._root.right							)

       return result






    def _snake_case    (     self							):
       if not self._root:
          raise IndexError('''Can\'t get top element for the empty heap.'''							)
       return self._root.value






    def _snake_case    (     self							):
       lowercase__:     Dict      =   None






    def _snake_case    (     self							):
       lowercase__:     Optional[int]      =   []
       while self:
          result.append(self.pop()							)

       return result






    def __bool__(     self							):
       return self._root is not None


if __name__ == "__main__":
       import doctest

       doctest.testmod()
