
from hashlib import mda, shaaaa

_UpperCamelCase:					Dict     =(shaaaa, mda)





class 						__lowercase:


       """simple docstring"""







       def __init__(     self					:			Optional[Any]  ,      _lowerCAmelCase					:			int = 8       )					->   None:
         _lowerCAmelCase						=		0B0
         _lowerCAmelCase						=		size



       def SCREAMING_SNAKE_CASE_				(     self					:			List[Any]  ,      _lowerCAmelCase					:			str       )					->   None:
         _lowerCAmelCase						=		self.hash_(_lowerCAmelCase       )
         self.bitarray |= h



       def SCREAMING_SNAKE_CASE_				(     self					:			Optional[Any]  ,      _lowerCAmelCase					:			str       )					->   bool:
         _lowerCAmelCase						=		self.hash_(_lowerCAmelCase       )
         return (h & self.bitarray) == h



       def __contains__(     self					:			Optional[int]  ,      _lowerCAmelCase					:			str       )					->   bool:
         return self.exists(_lowerCAmelCase       )



       def SCREAMING_SNAKE_CASE_				(     self					:			List[Any]  ,      _lowerCAmelCase					:			int       )					->   str:
         _lowerCAmelCase						=		bin(_lowerCAmelCase       )[2:]
         return res.zfill(self.size       )



       @property
       def SCREAMING_SNAKE_CASE_				(     self					:			List[Any]       )					->   str:
         return self.format_bin(self.bitarray       )



       def SCREAMING_SNAKE_CASE_				(     self					:			Optional[int]  ,      _lowerCAmelCase					:			str       )					->   int:
         _lowerCAmelCase						=		0B0
         for func in HASH_FUNCTIONS:
           _lowerCAmelCase						=		(
               int.from_bytes(func(value.encode()       ).digest()  ,      'little'       ) % self.size
           )
           res |= 2**position
         return res



       def SCREAMING_SNAKE_CASE_				(     self					:			Any  ,      _lowerCAmelCase					:			str       )					->   str:
         return self.format_bin(self.hash_(_lowerCAmelCase       )       )






       @property
       def SCREAMING_SNAKE_CASE_				(     self					:			Tuple       )					->   float:
         _lowerCAmelCase						=		bin(self.bitarray       ).count('1'       )
         return (n_ones / self.size) ** len(_lowerCAmelCase       )


import random



def 	_a  (					__SCREAMING_SNAKE_CASE					:  str    ):






  """simple docstring"""




  def is_sorted(__SCREAMING_SNAKE_CASE					:  str    ):
    for i in range(len(__SCREAMING_SNAKE_CASE    ) - 1    ):
      if collection[i] > collection[i + 1]:
        return False
    return True

  while not is_sorted(__SCREAMING_SNAKE_CASE    ):
    random.shuffle(__SCREAMING_SNAKE_CASE    )
  return collection


if __name__ == "__main__":
       _UpperCamelCase:					Dict     =input('Enter numbers separated by a comma:\n').strip()
       _UpperCamelCase:					Optional[Any]     =[int(item) for item in user_input.split(',')]
       print(bogo_sort(unsorted))
