// Copyright 2019 Ciobanu Bogdan-Calin
// [email protected]

#include <iostream>
#include <fstream>
#include <iomanip>
#include <vector>

std::ifstream f("gauss.in");
std::ofstream t("gauss.out");

#define NMAX 310
#define EPS 1e-6

template <typename T>
using Matrix = T[NMAX][NMAX];

template <typename T>
using Vector = T[NMAX];

int main() {
    // n is the number of equations, m the number of unknowns
    Matrix<double> A = {};
    Vector<double> b = {};
    Vector<double> x = {};
    std::vector<int> linear_independent_rows;
    int n, m;

    f >> n >> m;

    auto subtract_line_with_scalar = [&A, &b, m](int dst, int src, double scalar, int start = 0) mutable {
        for (int i = start; i < m; ++i)
            A[dst][i] -= A[src][i] * scalar;

        b[dst] -= b[src] * scalar;
    };

    auto divide_line_with_scalar = [&A, &b, m](int dst, double scalar, int start = 0) mutable {
        for (int i = start; i < m; ++i)
            A[dst][i] /= scalar;

        b[dst] /= scalar;
    };

    auto not_linear_independent = [&A, m](int dst) {
        bool flag = true;
        for (int i = 0; i < m; ++i) {
            flag &= (A[dst][i] < EPS ? true : false);
        }
        return flag;
    };

    // reading the matrix and results
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j)
            f >> A[i][j];
        f >> b[i];
    }

    for (int i = 0; i < m; ++i) {  // for each column
        divide_line_with_scalar(i, A[i][i], i); // no pivoting, but scaling
        for (int j = i + 1; j < n; ++j) { // rest to 0
            subtract_line_with_scalar(j, i, A[j][i], i);
        }

    }

    for (int i = 0; i < n; ++i)
        if (!not_linear_independent(i))
            linear_independent_rows.push_back(i);

    n = linear_independent_rows.size();
    std::cout << n << std::endl;

    if (n < m) {
        t << "Imposibil\n";
        return 0;
    }

    double sigma;
    // now perform back substitution
    for (int i = n - 1; i >= 0; --i) {
        sigma = .0;
        for (int j = m - 1; j > i; --j) {
            sigma += x[j] * A[linear_independent_rows[i]][j];
        }
        x[i] = (b[linear_independent_rows[i]] - sigma) / A[linear_independent_rows[i]][linear_independent_rows[i]];
    }

    t << std::setprecision(10) << std::fixed;
    for (int i = 0; i < m; ++i)
        t << x[i] << " ";

    return 0;
}