#include <bits/stdc++.h>

using namespace std;
using ll = long long;

const ll MOD = 1e9+7;
const int MAXN = 3001;
const int MAXM = 6001;

const int BLOCK_CNT = 55;
const int BLOCK_SIZE = 60;

const ll MULTI = (1ll<<(1+BLOCK_SIZE))%MOD;

struct bigint {

    vector<uint64_t> data;

    bigint() {
        data.assign(BLOCK_CNT, ~0ull);
    }

    void clear() {
        data.assign(BLOCK_CNT, 0ull);
    }

    bool operator<(const bigint &rhs) {
        for (int i = 0; i < BLOCK_CNT; i++) {
            if (data[i] != rhs.data[i]) {
                return data[i] < rhs.data[i];
            }
        }
        return 0;
    }

    bigint operator+(const bigint &rhs) {
        bigint res;
        res.clear();
        bool carry = 0;
        for (int i = BLOCK_CNT-1; i >= 0; i--) {
            res.data[i] = data[i] + rhs.data[i] + carry;
            carry = (res.data[i] >> (BLOCK_SIZE + 1)) & 1;
            res.data[i] &= ~(1ull << (BLOCK_SIZE + 1));
        }

        return res;
    }

    void inflate() {
        bool carry = 0;
        for (int i = BLOCK_CNT-1; i >= 0; i--) {
            bool next_carry = (data[i] >> BLOCK_SIZE) & 1;
            data[i] &= ~(1ull << BLOCK_SIZE);
            data[i] <<= 1;
            data[i] |= carry;
            carry = next_carry;
        }
    }

    ll calc_ans() {
        ll ans = 0;
        ll mul = 1;
        for (int i = BLOCK_CNT-1; i >= 0; i--) {
            data[i] %= MOD;
            ans += data[i] * mul;
            ans %= MOD;
            mul *= MULTI;
            mul %= MOD;
        }
        return ans;
    }
};

int u[MAXM], v[MAXM];

void solve() {
    int n, m; cin >> n >> m;
    vector<bigint> w(m+1);
    for (int i = 1; i <= m; i++) {
        w[i].clear();
        cin >> u[i] >> v[i] >> w[i].data.back();
    }
    vector<bigint> dist_last(n+1);
    vector<int> first_seen(n+1, n);
    vector<bool> vis_last(n+1);
    dist_last[1].clear();
    vis_last[1] = 1;
    int is_ok = -1;
    for (int i = 1; i <= n; i++) {

        vector<bigint> dist_curr = dist_last;
        vector<bool> vis_curr = vis_last;
        for (int j = 1; j <= m; j++) {
            if (first_seen[u[j]] + 35 >= i && vis_last[u[j]] && dist_last[u[j]] + w[j] < dist_curr[v[j]]) {
                dist_curr[v[j]] = dist_last[u[j]] + w[j];
                vis_curr[v[j]] = 1;
                first_seen[v[j]] = min(first_seen[v[j]], i);
            }
        }
        for (int j = 1; j <= m; j++) {
            if (first_seen[v[j]] + 35 >= i && vis_last[v[j]] && dist_last[v[j]] + w[j] < dist_curr[u[j]]) {
                dist_curr[u[j]] = dist_last[v[j]] + w[j];
                vis_curr[u[j]] = 1;
                first_seen[u[j]] = min(first_seen[u[j]], i);
            }
        }

        dist_last = dist_curr;
        vis_last = vis_curr;

        for (int j = 1; j <= m; j++) {
            w[j].inflate();
        }
    }

    for (int i = 2; i <= n; i++) {
        cout << dist_last[i].calc_ans() << "\n";
    }
    cout << "\n";
}

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    int t = 1; 
    // cin >> t;
    while (t--) solve();
    return 0;
}