





from __future__ import annotations

lowerCAmelCase_        =							1_0






def 	lowerCamelCase_		(							_UpperCamelCase					)						->		list[int]:






				"""simple docstring"""


				snake_case_		:       Optional[int]           =    1
				snake_case_		:       int           =    max(_UpperCamelCase					)
				while placement <= max_digit:
								# declare and initialize empty buckets
								snake_case_		:       list[list]           =    [[] for _ in range(_UpperCamelCase					)]
								# split list_of_ints between the buckets
								for i in list_of_ints:
												snake_case_		:       Tuple           =    int((i / placement) % RADIX					)
												buckets[tmp].append(_UpperCamelCase					)
								# put each buckets' contents into list_of_ints
								snake_case_		:       Optional[Any]           =    0
								for b in range(_UpperCamelCase					):
												for i in buckets[b]:
																snake_case_		:       Optional[int]           =    i
																a += 1
        # move to next
								placement *= RADIX
				return list_of_ints


if __name__ == "__main__":
	import doctest

	doctest.testmod()








'''simple docstring'''

def 				snake_case       (  a_				:			list[int]     , a_				:			list[int]						)							->					tuple[float, float]:





      """simple docstring"""

      if not len(a_						) == len(a_						) == 3:
            raise ValueError("""Please enter a valid equation."""						)
      if equationa[0] == equationa[1] == equationa[0] == equationa[1] == 0:
            raise ValueError("""Both a & b of two equations can't be zero."""						)

      # Extract the coefficients
      UpperCamelCase_     ,      UpperCamelCase_     ,      UpperCamelCase_					: Optional[int]            =				equationa
      UpperCamelCase_     ,      UpperCamelCase_     ,      UpperCamelCase_					: List[str]            =				equationa

      # Calculate the determinants of the matrices
      UpperCamelCase_					: Union[str, Any]            =				aa * ba - aa * ba
      UpperCamelCase_					: Dict            =				ca * ba - ca * ba
      UpperCamelCase_					: Dict            =				aa * ca - aa * ca

      # Check if the system of linear equations has a solution (using Cramer's rule)
      if determinant == 0:
            if determinant_x == determinant_y == 0:
                  raise ValueError("""Infinite solutions. (Consistent system)"""						)
            else:
                  raise ValueError("""No solution. (Inconsistent system)"""						)
      else:
            if determinant_x == determinant_y == 0:
                  # Trivial solution (Inconsistent system)
                  return (0.0, 0.0)
            else:
                  UpperCamelCase_					: List[Any]            =				determinant_x / determinant
                  UpperCamelCase_					: List[str]            =				determinant_y / determinant
                  # Non-Trivial Solution (Consistent system)
                  return (x, y)






