#include <iostream>
#include <algorithm>
#include <cmath>
#define SENTRY -1
#define ZERO_PRECISION 1e-6
#define TO_SKIP 1
#define DO_NOT_SKIP 0
#define ALL_ZERO 0
#define NOT_ALL_ZERO 1
using namespace std;

const int maxN = 100 + 10;

int matrixScale;

double augmentedMatrix[maxN][maxN]; //因为是循环式的重复计算，所以需要用一个矩阵存储下所有的值备查

void declaration(){
    scanf("%d", &matrixScale);
    for (int rowCounter = 1; rowCounter <= matrixScale; rowCounter ++){
        for (int columnCounter = 1; columnCounter <= matrixScale + 1; columnCounter ++){
            scanf("%lf", &augmentedMatrix[rowCounter][columnCounter]);
        }
    }
}

int rowRank = 1;
int columnRank = 1;

int rowCanvasForMaximumHead;

void selectMaximumRowHead(){
    rowCanvasForMaximumHead = SENTRY;
    for (int rowCandidate = rowRank; rowCandidate <= matrixScale; rowCandidate ++){
        if(rowCanvasForMaximumHead == SENTRY || fabs(augmentedMatrix[rowCandidate][columnRank]) > fabs(augmentedMatrix[rowCanvasForMaximumHead][columnRank])){
            rowCanvasForMaximumHead = rowCandidate;
        }
    }
}

int flagForSkipRound = DO_NOT_SKIP;

void setSkippingFlagToYes(){
    flagForSkipRound = TO_SKIP;
}

void setSkippingFlagToNo(){
    flagForSkipRound = DO_NOT_SKIP;
}

void testZeroHead(){
    if(fabs(augmentedMatrix[rowCanvasForMaximumHead][columnRank]) < ZERO_PRECISION){
        setSkippingFlagToYes();
    }
}

//注意是增广矩阵，多一列
void exchangeRowHead(){
    if (flagForSkipRound == DO_NOT_SKIP){
        for (int columnCounter = columnRank; columnCounter <= matrixScale + 1; columnCounter ++){
            swap(augmentedMatrix[rowCanvasForMaximumHead][columnCounter], augmentedMatrix[rowRank][columnCounter]);
        }
    }
}

void normalizeRow(){
    if (flagForSkipRound == DO_NOT_SKIP){
        double head = augmentedMatrix[rowRank][columnRank];
        for (int columnCounter = columnRank; columnCounter <= matrixScale + 1; columnCounter ++){
            augmentedMatrix[rowRank][columnCounter] /= head;
        }
    }
}

void rowTransformation(){
    if (flagForSkipRound == DO_NOT_SKIP){
        for (int rowCounter = rowRank + 1; rowCounter <= matrixScale; rowCounter ++){
            double head = augmentedMatrix[rowCounter][columnRank];
            for (int columnCounter = columnRank; columnCounter <= matrixScale + 1; columnCounter ++){
                augmentedMatrix[rowCounter][columnCounter] -= augmentedMatrix[rowRank][columnCounter] * head;
            }
        }
    }    
}
void rankCounterIncreasing(){
    if (flagForSkipRound == DO_NOT_SKIP){
        rowRank ++;
    }
    columnRank ++;
}

//TO DEBUG
void outputAStep(){
    for (int rowCounter = 1; rowCounter <= matrixScale; rowCounter ++){
        for (int columnCounter = 1; columnCounter <= matrixScale + 1; columnCounter ++){
            printf("%.2lf ", augmentedMatrix[rowCounter][columnCounter]);
        }
        printf("\n");
    }
    printf("\n");
}

void solveEquations(){
    for (int column = 1; column <= matrixScale; column ++){
        selectMaximumRowHead();
        testZeroHead();
        exchangeRowHead();
        normalizeRow();
        rowTransformation();
        rankCounterIncreasing();
        setSkippingFlagToNo();
    }
}

int restElement;

void checkRestZero(){
    for(int restCounter = rowRank; restCounter <= matrixScale; restCounter ++){
        if(fabs(augmentedMatrix[restCounter][matrixScale + 1]) > ZERO_PRECISION){
            restElement = NOT_ALL_ZERO;
        }
    }
}

void getSolution(){
    rowRank = matrixScale - 1;
    columnRank = matrixScale;
    while (rowRank >= 1){
        for (int rowCounter = rowRank; rowCounter >= 1; rowCounter --){
            double head = augmentedMatrix[rowCounter][columnRank];
            for (int columnCounter = columnRank; columnCounter <= matrixScale + 1; columnCounter ++){
                augmentedMatrix[rowCounter][columnCounter] -= augmentedMatrix[rowRank + 1][columnCounter] * head;
            }
        }
        rowRank --;
        columnRank --;
    }
    for (int rank = 1; rank <= matrixScale; rank ++){
        printf("%.2lf\n", augmentedMatrix[rank][matrixScale + 1]);
    }
}

void outputSolution(){
    checkRestZero();
    if (rowRank <= matrixScale && restElement == ALL_ZERO){
        printf("Infinite group solutions\n");
    }
    else if (rowRank <= matrixScale && restElement == NOT_ALL_ZERO){
        printf("No solution\n");
    }
    else{
        getSolution();
    }
}

int main(){
    declaration();
    solveEquations();
    outputSolution();
    return 0;
}