





from __future__ import annotations





def    _lowercase    (  _UpperCAmelCase )  ->     list[int]:
				if not list_of_ints:
								return []

				if min(_UpperCAmelCase ) < 0:
								raise ValueError("""All numbers must be positive""" )

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





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

				lowerCamelCase		       =[]
				lowerCamelCase		       =[]
				# 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(_UpperCAmelCase )
								else:
												# number has a zero at bit bit_position
												zeros.append(_UpperCAmelCase )

    # recursively split both lists further
				lowerCamelCase		       =_msd_radix_sort(_UpperCAmelCase	,					bit_position - 1 )
				lowerCamelCase		       =_msd_radix_sort(_UpperCAmelCase	,					bit_position - 1 )

				# recombine lists
				lowerCamelCase		       =zeros
				res.extend(_UpperCAmelCase )

				return res





def    _lowercase    (  _UpperCAmelCase )  ->     Optional[Any]:
				lowerCamelCase		       =len(_UpperCAmelCase )
				if not list_of_ints or length == 1:
								return

				if min(_UpperCAmelCase ) < 0:
								raise ValueError("""All numbers must be positive""" )

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





def    _lowercase    (  _UpperCAmelCase	,					_UpperCAmelCase	,					_UpperCAmelCase	,					_UpperCAmelCase )  ->     Tuple:
				if bit_position == 0 or end_index - begin_index <= 1:
								return

				bit_position -= 1

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

								if changed:
												continue

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

				_msd_radix_sort_inplace(_UpperCAmelCase	,					_UpperCAmelCase	,					_UpperCAmelCase	,					_UpperCAmelCase )
				_msd_radix_sort_inplace(_UpperCAmelCase	,					_UpperCAmelCase	,					_UpperCAmelCase	,					_UpperCAmelCase )


if __name__ == "__main__":
							import doctest

							doctest.testmod()













from math import factorial




def    __A    (   _lowercase    ,	_lowercase       ):

					'''simple docstring'''







					return factorial(_lowercase       ) / (factorial(_lowercase       ) * factorial(n - r       ))




def    __A    (   ):

					'''simple docstring'''







					_A									=       0

					for i in range(1    ,	1_01       ):
										for j in range(1    ,	i + 1       ):
															if combinations(_lowercase    ,	_lowercase       ) > 1e6:
																				total += 1
					return total


if __name__ == "__main__":
				print(solution())



