




SCREAMING_SNAKE_CASE:    Dict											=   {
    '''+''': lambda x, y: x + y,
    '''-''': lambda x, y: x - y,
    '''*''': lambda x, y: x * y,
    '''/''': lambda x, y: x / y,
}


def 				_a       (				lowerCAmelCase   )->  List[str]:
		return c.isdigit()


def 				_a       (				lowerCAmelCase   )->  List[Any]:
		SCREAMING_SNAKE_CASE_							=       []

		# iterate over the string in reverse order
		for c in expression.split()[::-1]:
				# push operand to stack
				if is_operand(lowerCAmelCase   ):
						stack.append(int(lowerCAmelCase   )   )

				else:
						# pop values from stack can calculate the result
						# push the result onto the stack again
						SCREAMING_SNAKE_CASE_							=       stack.pop()
						SCREAMING_SNAKE_CASE_							=       stack.pop()
						stack.append(calc[c](lowerCAmelCase						,	lowerCAmelCase   )   )

		return stack.pop()


# Driver code
if __name__ == "__main__":
						SCREAMING_SNAKE_CASE:    Any											=   '''+ 9 * 2 6'''
						print(evaluate(test_expression))

						SCREAMING_SNAKE_CASE:    Tuple											=   '''/ * 10 2 + 4 1 '''
						print(evaluate(test_expression))





from __future__ import annotations


def 				_a       (				lowerCAmelCase   )->  list[int]:
		if not list_of_ints:
				return []

		if min(lowerCAmelCase   ) < 0:
				raise ValueError('All numbers must be positive'   )

		SCREAMING_SNAKE_CASE_							=       max(len(bin(lowerCAmelCase   )[2:]   ) for x in list_of_ints   )
		return _msd_radix_sort(lowerCAmelCase						,	lowerCAmelCase   )


def 				_a       (				lowerCAmelCase						,	lowerCAmelCase   )->  list[int]:
		if bit_position == 0 or len(lowerCAmelCase   ) in [0, 1]:
				return list_of_ints

		SCREAMING_SNAKE_CASE_							=       []
		SCREAMING_SNAKE_CASE_							=       []
		# Split numbers based on bit at bit_position from the right
		for number in list_of_ints:
				if (number >> (bit_position - 1)) & 1:
						# number has a one at bit bit_position
						ones.append(lowerCAmelCase   )
				else:
						# number has a zero at bit bit_position
						zeros.append(lowerCAmelCase   )

    # recursively split both lists further
		SCREAMING_SNAKE_CASE_							=       _msd_radix_sort(lowerCAmelCase						,	bit_position - 1   )
		SCREAMING_SNAKE_CASE_							=       _msd_radix_sort(lowerCAmelCase						,	bit_position - 1   )

		# recombine lists
		SCREAMING_SNAKE_CASE_							=       zeros
		res.extend(lowerCAmelCase   )

		return res


def 				_a       (				lowerCAmelCase   )->  Dict:
		SCREAMING_SNAKE_CASE_							=       len(lowerCAmelCase   )
		if not list_of_ints or length == 1:
				return

		if min(lowerCAmelCase   ) < 0:
				raise ValueError('All numbers must be positive'   )

		SCREAMING_SNAKE_CASE_							=       max(len(bin(lowerCAmelCase   )[2:]   ) for x in list_of_ints   )
		_msd_radix_sort_inplace(lowerCAmelCase						,	lowerCAmelCase						,	0						,	lowerCAmelCase   )


def 				_a       (				lowerCAmelCase						,	lowerCAmelCase						,	lowerCAmelCase						,	lowerCAmelCase   )->  Optional[int]:
		if bit_position == 0 or end_index - begin_index <= 1:
				return

		bit_position -= 1

		SCREAMING_SNAKE_CASE_							=       begin_index
		SCREAMING_SNAKE_CASE_							=       end_index - 1
		while i <= j:
				SCREAMING_SNAKE_CASE_							=       False
				if not (list_of_ints[i] >> bit_position) & 1:
						# found zero at the beginning
						i += 1
						SCREAMING_SNAKE_CASE_							=       True
				if (list_of_ints[j] >> bit_position) & 1:
						# found one at the end
						j -= 1
						SCREAMING_SNAKE_CASE_							=       True

				if changed:
						continue

				SCREAMING_SNAKE_CASE_			,							SCREAMING_SNAKE_CASE_							=       list_of_ints[j], list_of_ints[i]
				j -= 1
				if j != i:
						i += 1

		_msd_radix_sort_inplace(lowerCAmelCase						,	lowerCAmelCase						,	lowerCAmelCase						,	lowerCAmelCase   )
		_msd_radix_sort_inplace(lowerCAmelCase						,	lowerCAmelCase						,	lowerCAmelCase						,	lowerCAmelCase   )


if __name__ == "__main__":
						import doctest

						doctest.testmod()