#include <bits/stdc++.h>

using namespace std;

const int MAX_N = 300;
const double EPS = 1e-8;

double A[MAX_N + 1][MAX_N + 1];
double ans[MAX_N];

int main() {
    ifstream fin("gauss.in");
    ofstream fout("gauss.out");
    fin.tie(0);
    ios_base::sync_with_stdio(false);

    int N, M; fin >> N >> M;
    int i, j;

    for (i = 0; i < N; ++ i) {
        for (j = 0; j <= M; ++ j) {
            fin >> A[i][j];
        }
    }

    for (j = 0; j < M; ++ j) {
        A[N][i] = 1.0;
    }

    i = 0; j = 0;

    while (i < N && j < M) {

        int k = i;
        while (fabs(A[k][j]) <= EPS) {
            ++ k;
        }

        if (k != N) {
            swap(A[i], A[k]);

            for (k = j + 1; k <= M; ++ k) {
                A[i][k] /= A[i][j];
            }

            A[i][j] = 1.0;

            for (k = i + 1; k < N; ++ k) {
                const double coef = A[k][j];

                for (int column = j; column <= M; ++ column) {
                    A[k][column] -= coef * A[i][column];
                }
            }
            ++ i;
        }
        ++ j;
    }

    for (i = N - 1; i >= 0; -- i) {
        j = 0;

        while (j <= M && fabs(A[i][j]) <= EPS) {
            ++ j;
        }

        if (j == M) {
            fout << "Imposibil\n";
            fout.close();
            return 0;
        } else if (j < M) {
            ans[j] = A[i][M];

            for (int k = j + 1; k < M; ++ k) {
                ans[j] -= ans[k] * A[i][k];
            }
        }
    }

    fout.precision(8); fout << fixed;
    for (i = 0; i < M; ++ i) {
        fout << ans[i] << ' ';
    }
    fout << '\n'; fout.close();

    return 0;
}