import java.util.*;
import java.io.*;

public class Main {
    static final int N = 110;
    static double[][] g = new double[N][N];
    static int n;
    static double esp = 1e-8;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        n = Integer.parseInt(br.readLine());
        for(int i = 0; i < n; i++) {
            String[] s = br.readLine().split(" ");                      
            for(int j = 0; j < n + 1; j++) {
                g[i][j] = Double.valueOf(s[j]);
            }
        }

        int t = gauss();

        if(t == 0) {
            for(int i = 0; i < n; i++) {
                System.out.println(String.format("%.2f", g[i][n]));
            }
        }else if(t == 1) {
            System.out.println("Infinite group solutions");
        }else {
            System.out.println("No solution");
        }
    }

    public static void swap(int x1, int y1, int x2, int y2) {
        double t = g[x1][y1];
        g[x1][y1] = g[x2][y2];
        g[x2][y2] = t;
    }

    public static int gauss() {
        int c, r;
        for(c = 0, r = 0; c < n; c++) {
            // 1. 找到每一列的最大值所在行
            int t = r;
            for(int i = r; i < n; i++) {
                if(Math.abs(g[i][c]) > Math.abs(g[t][c])) {
                    t = i;
                }
            }

            // 如果找到的值就是 0 的话直接跳过，相当于这个方程是多余的
            if(Math.abs(g[t][c]) < esp) continue;

            // 2. 将找到的当前行交换至顶端
            // 从 c 开始交换即可，前面列都是 0 了
            for(int i = c; i < n + 1; i++) swap(r, i, t, i);
            // 3. 将当前行的首位变为 1，其他位相应改变
            // 从后往前修改，避免 g[r][c] 一开始就变了
            for(int i = n; i >= c; i--) g[r][i] /= g[r][c];
            // 4. 用当前行将当前列的下面列都变为 0
            for(int i = r + 1; i < n; i++) {
                // 先判断要修改为 0 的位置是不是已经是 0 了
                if(Math.abs(g[i][c]) > esp) {
                    // 从后往前修改，避免 g[i][c] 一开始就变了
                    for(int j = n; j >= c; j--) {
                        g[i][j] -= g[i][c] * g[r][j];
                    }
                }
            }
            r++;
        }

        if(r < n) {
            // 从 r 开始是因为 r 所在位置就是矛盾的开始，而不是 r + 1
            // 因为在上面的循环中，当遇到矛盾时，会直接跳过，此时 r 的位置没有变
            for(int i = r; i < n; i++) {
                // 无解
                if(Math.abs(g[i][n]) > esp) {
                    return 2;
                }
            }
            // 无数多解
            return 1;
        }

        for(int i = n - 1; i >= 0; i--) {
            for(int j = i + 1; j < n; j++) {
                g[i][n] -= g[i][j] * g[j][n];
            }
        }

        // 唯一解
        return 0;
    }
}