




"""simple docstring"""





_lowercase		 =      [0.33, 0.44, 0.55, 0.44, 0.33]
_lowercase		 =      3
_lowercase		 =      5

# Buffer Space (with Parameters Space)
_lowercase		 =      []
_lowercase		 =      []

# Machine Time
_lowercase		 =      0

def 						lowerCAmelCase							(	lowerCamelCase						):
						'''simple docstring'''


						global buffer_space, params_space, machine_time, K, m, t

						# Choosing Dynamical Systems (All)
						for key, value in enumerate(__lowercase						):
												# Evolution Parameter
												snake_case__    :   Optional[Any]							     =   float(seed / value						)

												# Control Theory: Orbit Change
												snake_case__    :   Optional[Any]							     =   (buffer_space[(key + 1) % m] + e) % 1

												# Control Theory: Trajectory Change
												snake_case__    :   Tuple							     =   (params_space[key] + e) % 1 + 3

												# Modification (Transition Function) - Jumps
												snake_case__    :   Dict							     =   round(float(r * value * (1 - value)						) ,     10						)
												snake_case__    :   Union[str, Any]							     =   r  # Saving to Parameters Space

						# Logistic Map
						assert max(__lowercase						) < 1
						assert max(__lowercase						) < 4

						# Machine Time
						machine_time += 1

def 						lowerCAmelCase							(	):
						'''simple docstring'''


						global buffer_space, params_space, machine_time, K, m, t

						# PRNG (Xorshift by George Marsaglia)
						def xorshift(lowerCamelCase ,     lowerCamelCase						):
												x ^= y >> 13
												y ^= x << 17
												x ^= y >> 5
												return x

						# Choosing Dynamical Systems (Increment)
						snake_case__    :   int							     =   machine_time % m

						# Evolution (Time Length)
						for _ in range(0 ,     __lowercase						):
												# Variables (Position + Parameters)
												snake_case__    :   List[str]							     =   params_space[key]
												snake_case__    :   List[str]							     =   buffer_space[key]

												# Modification (Transition Function) - Flow
												snake_case__    :   Union[str, Any]							     =   round(float(r * value * (1 - value)						) ,     10						)
												snake_case__    :   str							     =   (machine_time * 0.01 + r * 1.01) % 1 + 3

						# Choosing Chaotic Data
						snake_case__    :   Optional[int]							     =   int(buffer_space[(key + 2) % m] * (10**10)						)
						snake_case__    :   List[Any]							     =   int(buffer_space[(key - 2) % m] * (10**10)						)

						# Machine Time
						machine_time += 1

						return xorshift(__lowercase ,     __lowercase						) % 0xff_ff_ff_ff

def 						lowerCAmelCase							(	):
						'''simple docstring'''


						global buffer_space, params_space, machine_time, K, m, t

						snake_case__    :   Optional[int]							     =   K
						snake_case__    :   Dict							     =   [0] * m
						snake_case__    :   Union[str, Any]							     =   0


if __name__ == "__main__":
	# Initialization
	reset()

	# Pushing Data (Input)
	import random

	_lowercase		 =      random.sample(range(0xFFFFFFFF), 1_00)
	for chunk in message:
		push(chunk)

	# for controlling
	_lowercase		 =      ""

	# Pulling Data (Output)
	while inp in ("e", "E"):
		print(f"""{format(pull(), "#04x")}""")
		print(buffer_space)
		print(params_space)
		_lowercase		 =      input("""(e)exit? """).strip()








"""simple docstring"""





class  __lowercase    :


				'''simple docstring'''


				class  __lowercase    :


								'''simple docstring'''


								_lowerCAmelCase		     ="_prev", "_data", "_next"

								def __init__(				self				:       List[Any] ,SCREAMING_SNAKE_CASE_				:       int ,SCREAMING_SNAKE_CASE_				:       Union[str, Any] ,SCREAMING_SNAKE_CASE_				:       Any ):
														snake_case__    :   Any							     =   link_p
														snake_case__    :   List[str]							     =   element
														snake_case__    :   str							     =   link_n





								def  _lowerCamelCase   (				self				:       Optional[Any] ):
														return (
														    F''' Prev -> {self._prev is not None}, Next -> {self._next is not None}'''
														)







				def __init__(				self				:       Any ):
										snake_case__    :   int							     =   self._Node(SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ )
										snake_case__    :   Optional[int]							     =   self._Node(SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ )
										snake_case__    :   Union[str, Any]							     =   self._trailer
										snake_case__    :   Union[str, Any]							     =   self._header
										snake_case__    :   Any							     =   0

				def __len__(				self				:       str ):
										return self._size

				def  _lowerCamelCase   (				self				:       Union[str, Any] ):
										return self.__len__() == 0

				def  _lowerCamelCase   (				self				:       Any ,SCREAMING_SNAKE_CASE_				:       List[Any] ,SCREAMING_SNAKE_CASE_				:       List[str] ,SCREAMING_SNAKE_CASE_				:       Dict ):
										# Create new_node by setting it's prev.link -> header
										# setting it's next.link -> trailer
										snake_case__    :   Dict							     =   self._Node(SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ )
										snake_case__    :   Any							     =   new_node
										snake_case__    :   str							     =   new_node
										self._size += 1
										return self





				def  _lowerCamelCase   (				self				:       Union[str, Any] ,SCREAMING_SNAKE_CASE_				:       Dict ):
										snake_case__    :   Union[str, Any]							     =   node._prev
										snake_case__    :   Union[str, Any]							     =   node._next

										snake_case__    :   List[Any]							     =   successor
										snake_case__    :   Dict							     =   predecessor
										self._size -= 1
										snake_case__    :   Dict							     =   node._data
										snake_case__    :   List[str]							     =   None
										del node
										return temp







class  __lowercase    (     _DoublyLinkedBase		):


				'''simple docstring'''


				def  _lowerCamelCase   (				self				:       Optional[int] ):
										if self.is_empty():
																raise Exception('''List is empty''' )
										return self._header._next._data

				def  _lowerCamelCase   (				self				:       Union[str, Any] ):
										if self.is_empty():
																raise Exception('''List is empty''' )
										return self._trailer._prev._data

				def  _lowerCamelCase   (				self				:       Any ,SCREAMING_SNAKE_CASE_				:       Dict ):
										return self._insert(self._header ,SCREAMING_SNAKE_CASE_ ,self._header._next )

				def  _lowerCamelCase   (				self				:       Dict ,SCREAMING_SNAKE_CASE_				:       Union[str, Any] ):
										return self._insert(self._trailer._prev ,SCREAMING_SNAKE_CASE_ ,self._trailer )

				def  _lowerCamelCase   (				self				:       Optional[int] ):
										if self.is_empty():
																raise IndexError('''remove_first from empty list''' )
										return self._delete(self._header._next )





				def  _lowerCamelCase   (				self				:       Optional[Any] ):
										if self.is_empty():
																raise IndexError('''remove_first from empty list''' )
										return self._delete(self._trailer._prev )


