



def 							UpperCAmelCase__		(				_SCREAMING_SNAKE_CASE   :	list[list]				)->list[list]:
      _lowerCAmelCase 			=  current_set.copy()
      for row_index, row in enumerate(_SCREAMING_SNAKE_CASE				):
            _lowerCAmelCase 			=  row[0]
            for column_index, column in enumerate(_SCREAMING_SNAKE_CASE				):
                  if magnitude == 0:
                        _lowerCAmelCase 			=  column
                        continue
                  _lowerCAmelCase 			=  column / magnitude
    # Subtract to cancel term
      _lowerCAmelCase 			=  current_set[0]
      _lowerCAmelCase 			=  [first_row]
      _lowerCAmelCase 			=  current_set[1::]
      for row in current_set:
            _lowerCAmelCase 			=  []
            # If first term is 0, it is already in form we want, so we preserve it
            if row[0] == 0:
                  final_set.append(_SCREAMING_SNAKE_CASE				)
                  continue
            for column_index in range(len(_SCREAMING_SNAKE_CASE				)				):
                  temp_row.append(first_row[column_index] - row[column_index]				)
            final_set.append(_SCREAMING_SNAKE_CASE				)
      # Create next recursion iteration set
      if len(final_set[0]				) != 3:
            _lowerCAmelCase 			=  final_set[0]
            _lowerCAmelCase 			=  []
            _lowerCAmelCase 			=  []
            for row in final_set[1::]:
                  current_first_column.append(row[0]				)
                  next_iteration.append(row[1::]				)
            _lowerCAmelCase 			=  simplify(_SCREAMING_SNAKE_CASE				)
            for i in range(len(_SCREAMING_SNAKE_CASE				)				):
                  resultant[i].insert(0     ,				current_first_column[i]				)
            resultant.insert(0     ,				_SCREAMING_SNAKE_CASE				)
            _lowerCAmelCase 			=  resultant
      return final_set
def 							UpperCAmelCase__		(				_SCREAMING_SNAKE_CASE   :	list[list]				)->list:
      if len(_SCREAMING_SNAKE_CASE				) == 0:
            raise IndexError('''solve_simultaneous() requires n lists of length n+1'''				)
      _lowerCAmelCase 			=  len(_SCREAMING_SNAKE_CASE				) + 1
      if any(len(_SCREAMING_SNAKE_CASE				) != _length for item in equations				):
            raise IndexError('''solve_simultaneous() requires n lists of length n+1'''				)
      for row in equations:
            if any(not isinstance(_SCREAMING_SNAKE_CASE     ,				(int, float)				) for column in row				):
                  raise ValueError('''solve_simultaneous() requires lists of integers'''				)
      if len(_SCREAMING_SNAKE_CASE				) == 1:
            return [equations[0][-1] / equations[0][0]]
      _lowerCAmelCase 			=  equations.copy()
      if any(0 in row for row in data_set				):
            _lowerCAmelCase 			=  data_set.copy()
            _lowerCAmelCase 			=  []
            for row_index, row in enumerate(_SCREAMING_SNAKE_CASE				):
                  if 0 not in row:
                        _lowerCAmelCase 			=  data_set.pop(_SCREAMING_SNAKE_CASE				)
                        break
            if not full_row:
                  raise ValueError('''solve_simultaneous() requires at least 1 full equation'''				)
            data_set.insert(0     ,				_SCREAMING_SNAKE_CASE				)
      _lowerCAmelCase 			=  data_set.copy()
      _lowerCAmelCase 			=  simplify(_SCREAMING_SNAKE_CASE				)
      _lowerCAmelCase 			=  simplified[::-1]
      _lowerCAmelCase 			=  []
      for row in simplified:
            _lowerCAmelCase 			=  row[-1]
            if not solutions:
                  if row[-2] == 0:
                        solutions.append(0				)
                        continue
                  solutions.append(current_solution / row[-2]				)
                  continue
            _lowerCAmelCase 			=  row.copy()[: len(_SCREAMING_SNAKE_CASE				) - 1 :]
            while temp_row[0] == 0:
                  temp_row.pop(0				)
            if len(_SCREAMING_SNAKE_CASE				) == 0:
                  solutions.append(0				)
                  continue
            _lowerCAmelCase 			=  temp_row[1::]
            _lowerCAmelCase 			=  temp_row[::-1]
            for column_index, column in enumerate(_SCREAMING_SNAKE_CASE				):
                  current_solution -= column * solutions[column_index]
            solutions.append(_SCREAMING_SNAKE_CASE				)
      _lowerCAmelCase 			=  []
      for item in solutions:
            final.append(float(round(_SCREAMING_SNAKE_CASE     ,				5				)				)				)
      return final[::-1]


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    UpperCAmelCase_									=							[
        [2, 1, 1, 1, 1, 4],
        [1, 2, 1, 1, 1, 5],
        [1, 1, 2, 1, 1, 6],
        [1, 1, 1, 2, 1, 7],
        [1, 1, 1, 1, 2, 8],
    ]
    print(solve_simultaneous(eq))
    print(solve_simultaneous([[4, 2]]))




def 							UpperCAmelCase__		(				_SCREAMING_SNAKE_CASE   :	Optional[Any]				)->Any:  # noqa: E741
      _lowerCAmelCase 			=  len(_SCREAMING_SNAKE_CASE				)
      _lowerCAmelCase 			=  0
      _lowerCAmelCase 			=  [0] * n
      _lowerCAmelCase 			=  [False] * n
      _lowerCAmelCase 			=  [False] * n

      def dfs(_SCREAMING_SNAKE_CASE   :	List[str]     ,				_SCREAMING_SNAKE_CASE   :	List[Any]     ,				_SCREAMING_SNAKE_CASE   :	Optional[int]     ,				_SCREAMING_SNAKE_CASE   :	int				):
            if parent == root:
                  out_edge_count += 1
            _lowerCAmelCase 			=  True
            _lowerCAmelCase 			=  at

            for to in l[at]:
                  if to == parent:
                        pass
                  elif not visited[to]:
                        _lowerCAmelCase 			=  dfs(_SCREAMING_SNAKE_CASE     ,				_SCREAMING_SNAKE_CASE     ,				_SCREAMING_SNAKE_CASE     ,				_SCREAMING_SNAKE_CASE				)
                        _lowerCAmelCase 			=  min(low[at]     ,				low[to]				)

                        # AP found via bridge
                        if at < low[to]:
                              _lowerCAmelCase 			=  True
                        # AP found via cycle
                        if at == low[to]:
                              _lowerCAmelCase 			=  True
                  else:
                        _lowerCAmelCase 			=  min(low[at]     ,				_SCREAMING_SNAKE_CASE				)
            return out_edge_count

      for i in range(_SCREAMING_SNAKE_CASE				):
            if not visited[i]:
                  _lowerCAmelCase 			=  0
                  _lowerCAmelCase 			=  dfs(_SCREAMING_SNAKE_CASE     ,				_SCREAMING_SNAKE_CASE     ,				-1     ,				_SCREAMING_SNAKE_CASE				)
                  _lowerCAmelCase 			=  out_edge_count > 1

      for x in range(len(_SCREAMING_SNAKE_CASE				)				):
            if is_art[x] is True:
                  print(_SCREAMING_SNAKE_CASE				)


# Adjacency list of graph
UpperCAmelCase_									=							{
    0: [1, 2],
    1: [0, 2],
    2: [0, 1, 3, 5],
    3: [2, 4],
    4: [3],
    5: [2, 6, 8],
    6: [5, 7],
    7: [6, 8],
    8: [5, 7],
}


compute_ap(data)