#include <bits/stdc++.h>

constexpr int mod = 1e9 + 7;
constexpr int base = 10;

int add(int a, int b) {
    return a + b - mod * (a + b >= mod);
}
int mul(int a, int b) {
    return a * 1ULL * b % mod;
}

struct Fuck {
    int a, b;  // a * x + b
};

// !  B(A(x))
Fuck compose(Fuck a, Fuck b) {
    return Fuck{mul(a.a, b.a), add(mul(a.b, b.a), b.b)};
}

int32_t main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n, m;
    std::cin >> n >> m;
    std::vector<std::array<int, 3>> edg(m);
    for (int i = 0; i < m; i++) {
        auto &[u, v, id] = edg[i];
        std::cin >> u >> v;
        u--;
        v--;
        id = i + 1;
    }
    {
        struct DSU {
            std::vector<int> prv;

            DSU(int n) : prv(n, -1) { ; }

            int get(int i) { return prv[i] == -1 ? i : prv[i] = get(prv[i]); }
        } dsu(n);

        std::vector<std::array<int, 3>> edg2;
        for (auto e : edg) {
            if (dsu.get(e[0]) != dsu.get(e[1])) {
                dsu.prv[dsu.get(e[0])] = dsu.get(e[1]);
                edg2.push_back(e);
            }
        }
        edg = edg2;
    }
    assert(edg.size() == n - 1);

    std::vector<Fuck> fuck(n, Fuck{1, 0});
    std::vector<int> prv(n, -1);

    auto get = [&](auto get, int v) -> std::pair<int, Fuck> {
        if (prv[v] == -1) {
            return {v, fuck[v]};
        }
        auto [pv, pf] = get(get, prv[v]);
        prv[v] = pv;
        fuck[v] = compose(fuck[v], pf);
        return {pv, fuck[v]};
    };

    for (auto [u, v, w] : edg) {
        int id = prv.size();
        prv.push_back(-1);
        fuck.push_back(Fuck{1, 0});
        auto [u2, fu] = get(get, u);
        auto [v2, fv] = get(get, v);
        fuck[u2] = compose(Fuck{base, w}, fv);
        fuck[v2] = compose(Fuck{base, w}, fu);
        prv[u2] = id;
        prv[v2] = id;
    }

    for (int i = 0; i < n; i++) {
        auto [u, f] = get(get, i);
        std::cout << f.b << " \n"[i == n - 1];
    }

    return 0;
}