#include <algorithm>
#include <cassert>
#include <iostream>
#include <iterator>
#include <vector>

const int MOD = 1e9 + 7;

long long ex_gcd(long long a, long long b, long long &x, long long &y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    long long d = ex_gcd(b, a % b, y, x);
    y -= a / b * x;
    return d;
}

long long inv(long long a) {
    long long x, y;
    a = (a + MOD) % MOD;
    ex_gcd(a, MOD, x, y);
    return (x % MOD + MOD) % MOD;
}

struct Matrix {
    std::vector<std::vector<long long>> mat;
    size_t n, m;
    Matrix(size_t n, size_t m) : n(n), m(m) {
        mat.resize(n);
        for (auto &v: mat) {
            v.resize(m);
        }
    }
    long long &operator()(size_t i, size_t j) {
        return mat[i][j];
    }
    std::vector<long long> &operator()(size_t i) {
        return mat[i];
    }

    Matrix argument(std::vector<long long> v) const {
        assert(n == v.size());
        Matrix res(n, m + 1);
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                res(i, j) = mat[i][j];
            }
            res(i, m) = v[i];
        }
        return res;
    }

    Matrix transpose() const {
        Matrix res(m, n);
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                res(j, i) = mat[i][j];
            }
        }
        return res;
    }

    [[nodiscard]] Matrix remove_column(size_t k) const {
        assert(m != 1 && k < m);
        Matrix res(n, m - 1);
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m - 1; ++j) {
                res(i, j) = mat[i][j < k ? j : j + 1];
            }
        }
        return res;
    }
    Matrix remove_row(size_t k) const {
        assert(n != 1 && k < n);
        Matrix res(n - 1, m);
        for (int i = 0; i < n - 1; ++i) {
            for (int j = 0; j < m; ++j) {
                res(i, j) = mat[i < k ? i : i + 1][j];
            }
        }
        return res;
    }

    long long determinate() const {
        assert(n == m);
        Matrix tmp = *this;
        long long res = 1;
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                while (tmp(j, i) != 0) {
                    long long t = tmp(i, i) / tmp(j, i);
                    for (int k = i; k < n; ++k) {
                        tmp(i, k) = (tmp(i, k) - t * tmp(j, k)) % MOD;
                    }
                    std::swap(tmp(i), tmp(j));
                    res = -res;
                }
            }
            res = (res * tmp(i, i)) % MOD;
        }
        return res;
    }

    std::vector<std::vector<long long>> Gaussian_elimination(const std::vector<long long> &v) const {
        assert(n == v.size());
        std::vector<long long> v0(m);
        Matrix tmp = this->argument(v);
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                while (tmp(j, i) != 0) {
                    long long t = tmp(i, i) / tmp(j, i);
                    for (int k = i; k <= m; ++k) {
                        tmp(i, k) = (tmp(i, k) - t * tmp(j, k)) % MOD;
                    }
                    std::swap(tmp(i), tmp(j));
                }
            }
        }

        for (int i = n - 1; i >= 0; --i) {
            if (tmp(i, i) == 0) {
                continue;
            }
            long long t = inv(tmp(i, i));
            for (int j = i; j <= m; ++j) {
                tmp(i, j) = tmp(i, j) * t % MOD;
            }
            tmp(i, i) = 1;
            for (int j = 0; j < i; ++j) {
                auto s = tmp(j, i);
                for (int k = i; k <= m; ++k) {
                    tmp(j, k) = (tmp(j, k) - tmp(i, k) * s) % MOD;
                }
            }
            v0[i] = tmp(i, m);
        }
        std::vector<std::vector<long long>> res;
        res.push_back(v0);
        for (int i = 0; i < n; ++i) {
            if (tmp(i, i) == 0) {
                std::vector<long long> v(m, 0);
                v[i] = 1;
                for (int j = 0; j < n; ++j) {
                    if (i != j) {
                        v[j] = -tmp(j, i);
                    }
                }
                res.push_back(v);
            }
        }
        return res;
    }
};

int main() {
    int _;
    for (scanf("%d", &_); _ != 0; --_) {
        int n, m;
        scanf("%d%d", &n, &m);
        if (n == 1) {
            puts("1");
            continue;
        }
        Matrix mat(n, n);
        for (int i = 0; i < m; ++i) {
            int u, v;
            scanf("%d%d", &u, &v);
            --u, --v;
            mat(u, v) -= 1;
            mat(v, v) += 1;
        }
        auto x = mat.Gaussian_elimination(std::vector<long long>(n, 0))[1];
        auto y = mat.transpose().Gaussian_elimination(std::vector<long long>(n, 0))[1];
        auto none_zero = [](int x) {
            return x != 0;
        };
        int i = (int) (std::find_if(x.begin(), x.end(), none_zero) - x.begin());
        int j = (int) (std::find_if(y.begin(), y.end(), none_zero) - y.begin());
        auto tx = inv(x[i]);
        auto ty = inv(y[j]);
        for (int k = 0; k < n; ++k) {
            x[k] = x[k] * tx % MOD;
            y[k] = y[k] * ty % MOD;
        }
        auto det = mat.remove_column(i).remove_row(j).determinate();
        if ((i + j) & 1) {
            det = -det;
        }
        for (int k = 0; k < n; ++k) {
            long long ans = det * x[k] % MOD * y[k] % MOD;
            printf("%lld ", (ans + MOD) % MOD);
        }
        puts("");
    }
    return 0;
}