#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

const int MOD = 998244353;

int add(int a, int b) {
  if (a + b < MOD)
    return a + b;
  return a + b - MOD;
}

int sub(int a, int b) {
  if (a >= b)
    return a - b;
  return a + MOD - b;
}

int mul(int a, int b) {
  return a * 1ll * b % MOD;
}

int pw(int a, int n) {
  int ans = 1;
  while (n) {
    if (n & 1) {
      ans = mul(ans, a);
    }
    n >>= 1;
    a = mul(a, a);
  }
  return ans;
}

const int MAXN = 100100;
int used[MAXN];
vector<pair<int, int>> G1[MAXN];

vector<pair<int, int>> Gtree[MAXN];
vector<pair<int, int>> from[MAXN];

const int K = 17;
int tin[MAXN];
int tout[MAXN];
int depth[MAXN];
int up[MAXN][K];
int up_prob[MAXN][K];
int ttime = 0;

void dfs1(int v, int par, int prob, int d) {
  tin[v] = ttime;
  ++ttime;
  up[v][0] = par;
  up_prob[v][0] = prob;
  depth[v] = d;
  used[v] = 1;
  for (auto [u, p] : G1[v]) {
    if (used[u] == 0) {
      Gtree[v].emplace_back(u, p);
      //cout << "tree " << v << ' ' << u << ' ' << p << '\n';
      dfs1(u, v, p, d + 1);
    } else if (used[u] == 1) {
      // skip
    } else {
      from[u].emplace_back(v, p);
      //cout << "left " << v << ' ' << u << ' ' << p << '\n';
    }
  }
  used[v] = 2;
  tout[v] = ttime;
}

int la(int v, int d) {
  for (int k = K - 1; k >= 0; --k) {
    if (d >= (1 << k)) {
      d -= 1 << k;
      v = up[v][k];
    }
  }
  return v;
}

int lca(int v, int u) {
  if (depth[v] >= depth[u])
    v = la(v, depth[v] - depth[u]);
  else
    u = la(u, depth[u] - depth[v]);
  if (v == u)
    return v;
  for (int k = K - 1; k >= 0; --k) {
    if (up[v][k] != up[u][k]) {
      v = up[v][k];
      u = up[u][k];
    }
  }
  return up[v][0];
}

bool is_par(int v, int u) {
  return tin[v] <= tin[u] && tout[u] <= tout[v];
}

vector<pair<int, int>> G2[MAXN];
int vals[MAXN];
int dp[MAXN];

void dfs2(int v) {
  dp[v] = vals[v];
  for (auto [u, p] : G2[v]) {
    dfs2(u);
    dp[u] = mul(dp[u], p);
    dp[v] = sub(1, mul(sub(1, dp[v]), sub(1, dp[u])));
  }
}

int calc_ans(int v) {
  vector<int> vertices;
  from[v].emplace_back(v, 1);
  vertices.emplace_back(0);
  for (auto [u, p] : from[v])
    vertices.emplace_back(u);
  sort(vertices.begin(), vertices.end(), [](int a, int b) {
    return tin[a] < tin[b];
  });
  int k = vertices.size();
  for (int i = 0; i + 1 < k; ++i) {
    int l = lca(vertices[i], vertices[i + 1]);
    vertices.emplace_back(l);
  }
  sort(vertices.begin(), vertices.end(), [](int a, int b) {
    return tin[a] < tin[b];
  });
  vertices.resize(unique(vertices.begin(), vertices.end()) - vertices.begin());

  vector<int> stack;
  for (auto u : vertices) {
    while (!stack.empty() && !is_par(stack.back(), u))
      stack.pop_back();
    if (!stack.empty()) {
      int par = stack.back();
      int w = 1;
      int tmp = u;
      int d = depth[u] - depth[par];
      for (int k = K - 1; k >= 0; --k) {
        if (d >= (1 << k)) {
          w = mul(w, up_prob[tmp][k]);
          tmp = up[tmp][k];
          d -= (1 << k);
        }
      }
      // edge from par to u with weight w
      G2[par].emplace_back(u, w);
    }
    stack.emplace_back(u);
  }
  for (int u : vertices)
    vals[u] = 0;
  for (auto [u, w] : from[v])
    vals[u] = w;
  dfs2(0);
  for (int u : vertices) {
    G2[u].clear();
  }
  return dp[0];
}


int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);

  int n, m;
  cin >> n >> m;
  for (int i = 0; i < m; ++i) {
    int u, v, p, q;
    cin >> u >> v >> p >> q;
    int w = mul(p, pw(q, MOD - 2));
    --u;
    --v;
    G1[u].emplace_back(v, w);
  }
  dfs1(0, 0, 1, 0);
  for (int j = 1; j < K; ++j) {
    for (int i = 0; i < n; ++i) {
      up[i][j] = up[up[i][j - 1]][j - 1];
      up_prob[i][j] = mul(up_prob[i][j - 1], up_prob[up[i][j - 1]][j - 1]);
    }
  }
  for (int i = 0; i < n; ++i)
    cout << calc_ans(i) << '\n';
  return 0;
}