#include #include using namespace std; typedef unsigned long long _ulong; typedef long long int lint; typedef pair plint; typedef pair pld; #define ALL(x) (x).begin(), (x).end() #define SZ(x) ((lint)(x).size()) #define FOR(i, begin, end) for(lint i=(begin),i##_end_=(end);i=i##_begin_;--i) #define REP(i, n) FOR(i,0,n) #define IREP(i, n) IFOR(i,0,n) #define endk '\n' #define fi first #define se second struct fast_ios { fast_ios() { cin.tie(nullptr), ios::sync_with_stdio(false), cout << fixed << setprecision(20); }; } fast_ios_; template auto add = [](T a, T b) -> T { return a + b; }; template auto f_max = [](T a, T b) -> T { return max(a, b); }; template auto f_min = [](T a, T b) -> T { return min(a, b); }; template using V = vector; using Vl = V; using VVl = V; template< typename T > ostream& operator<<(ostream& os, const vector< T >& v) { for (int i = 0; i < (int)v.size(); i++) os << v[i] << (i + 1 != v.size() ? " " : ""); return os; } template< typename T >istream& operator>>(istream& is, vector< T >& v) { for (T& in : v) is >> in; return is; } template bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; } template bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; } lint gcd(lint a, lint b) { if (b == 0) return a; else return gcd(b, a % b); } lint ceil(lint a, lint b) { return (a + b - 1) / b; } lint digit(lint a) { return (lint)log10(a); } lint e_dist(plint a, plint b) { return abs(a.fi - b.fi) * abs(a.fi - b.fi) + abs(a.se - b.se) * abs(a.se - b.se); } lint m_dist(plint a, plint b) { return abs(a.fi - b.fi) + abs(a.se - b.se); } void Worshall_Floyd(VVl& g) { REP(k, SZ(g)) REP(i, SZ(g)) REP(j, SZ(g)) chmin(g[i][j], g[i][k] + g[k][j]); } const lint MOD = 1e9 + 7, INF = 1e9 + 1; lint dx[8] = { 1, 0, -1, 0, 1, -1, 1, -1 }, dy[8] = { 0, 1, 0, -1, -1, -1, 1, 1 }; bool YN(bool flag) { cout << (flag ? "YES" : "NO") << endk; return flag; } bool yn(bool flag) { cout << (flag ? "Yes" : "No") << endk; return flag; } struct Edge { lint from, to; lint cost; Edge(lint u, lint v, lint c) { cost = c; from = u; to = v; } bool operator<(const Edge& e) const { return cost < e.cost; } }; struct WeightedEdge { lint to; lint cost; WeightedEdge(lint v, lint c = 1) { to = v; cost = c; } bool operator<(const WeightedEdge& e) const { return cost < e.cost; } }; using WeightedGraph = V>; typedef pair tlint; typedef pair qlint; typedef pair valstring; template class modint { using u64 = std::int_fast64_t; public: u64 a; constexpr modint(const u64 x = 0) noexcept : a(x% Modulus) {} constexpr u64& value() noexcept { return a; } constexpr const u64& value() const noexcept { return a; } constexpr modint operator+(const modint rhs) const noexcept { return modint(*this) += rhs; } constexpr modint operator-(const modint rhs) const noexcept { return modint(*this) -= rhs; } constexpr modint operator*(const modint rhs) const noexcept { return modint(*this) *= rhs; } constexpr modint operator/(const modint rhs) const noexcept { return modint(*this) /= rhs; } constexpr modint& operator+=(const modint rhs) noexcept { a += rhs.a; if (a >= Modulus) { a -= Modulus; } return *this; } constexpr modint& operator-=(const modint rhs) noexcept { if (a < rhs.a) { a += Modulus; } a -= rhs.a; return *this; } constexpr modint& operator*=(const modint rhs) noexcept { a = a * rhs.a % Modulus; return *this; } constexpr modint& operator/=(modint rhs) noexcept { u64 exp = Modulus - 2; while (exp) { if (exp % 2) { *this *= rhs; } rhs *= rhs; exp /= 2; } return *this; } }; typedef modint ModInt; ModInt mod_pow(ModInt x, lint n) { ModInt ret = 1; while (n > 0) { if (n & 1) (ret *= x); (x *= x); n >>= 1; } return ret; } ModInt func[200000]; void funcinit(int N) { func[0] = 1; for (int i = 1; i <= N; i++) { func[i] = func[i - 1] * i; } } ModInt comb(ModInt n, ModInt r) { if (n.a <= 0 || n.a < r.a) { return 1; } return func[n.a] / (func[r.a] * func[(n - r).a]); } struct Topological_Sort { public: Topological_Sort(int _n) : G(_n, Vl()), indegree(_n, 0), N(_n) {} void add_edge(int u, int v) { G[u].push_back(v); indegree[v]++; } Vl get() { Vl sorted_vertices; Vl tmp_indegree = indegree; queue que; REP(i, N) { if (tmp_indegree[i] == 0) que.push(i); } while (!que.empty()) { int v = que.front(); que.pop(); REP(i, SZ(G[v])) { int u = G[v][i]; tmp_indegree[u]--; if (tmp_indegree[u] == 0) que.push(u); } sorted_vertices.push_back(v); } return sorted_vertices; } private: VVl G; Vl indegree; int N; }; struct UnionFind { public: UnionFind() : _n(0) {} UnionFind(int n) : _n(n), parent_or_size(n, -1) {} int merge(int a, int b) { assert(0 <= a && a < _n); assert(0 <= b && b < _n); int x = leader(a), y = leader(b); if (x == y) return x; if (-parent_or_size[x] < -parent_or_size[y]) std::swap(x, y); if (used_count) { if (count_in_set[x].size() < count_in_set[y].size()) { std::swap(count_in_set[x], count_in_set[y]); } for (auto p : count_in_set[y]) { count_in_set[x][p.first] += p.second; } } if (set_operate) { root_values[x] = f(root_values[y], root_values[x]); } parent_or_size[x] += parent_or_size[y]; parent_or_size[y] = x; return x; } bool same(int a, int b) { assert(0 <= a && a < _n); assert(0 <= b && b < _n); return leader(a) == leader(b); } int leader(int a) { assert(0 <= a && a < _n); if (parent_or_size[a] < 0) return a; return parent_or_size[a] = leader(parent_or_size[a]); } int size(int a) { assert(0 <= a && a < _n); return -parent_or_size[leader(a)]; } std::vector> groups() { std::vector leader_buf(_n), group_size(_n); for (int i = 0; i < _n; i++) { leader_buf[i] = leader(i); group_size[leader_buf[i]]++; } std::vector> result(_n); for (int i = 0; i < _n; i++) { result[i].reserve(group_size[i]); } for (int i = 0; i < _n; i++) { result[leader_buf[i]].push_back(i); } result.erase( std::remove_if(result.begin(), result.end(), [&](const std::vector& v) { return v.empty(); }), result.end()); return result; } //update root calc //set by set operations void set_operate_and_value(std::vector array, function _f) { f = _f; root_values = array; set_operate = true; } lint get_set_value(int a) { return root_values[leader(a)]; } //regist count void regist_count(int a, int label) { if (!used_count) { used_count = true; count_in_set.assign(_n, std::map()); } count_in_set[leader(a)][label]++; } int get_count(int a, int label) { if (!used_count) return -1; return count_in_set[leader(a)][label]; } private: int _n; std::vector parent_or_size; std::vector> count_in_set; bool used_count = false; std::vector root_values; function f; bool set_operate = false; }; lint N, M, u, v, l, a; int main() { cin >> N >> M; V> rev(N + 1, V()); VVl to(N + 1, Vl()); Topological_Sort topo(N + 1); V edges; UnionFind tree(N + 1); REP(i, M) { cin >> u >> v >> l >> a; rev[v].push_back({ u, {l, a} }); edges.push_back({ u, v }); tree.merge(u, v); to[u].push_back(v); to[v].push_back(u); } queue que; deque visited(N + 1, false); que.push(0); visited[0] = true; while (!que.empty()) { lint curr = que.front(); que.pop(); for (lint nxt : to[curr]) { if (visited[nxt]) continue; visited[nxt] = true; que.push(nxt); } } REP(i, M) { if (tree.same(0, edges[i].first)) { topo.add_edge(edges[i].first, edges[i].second); } } auto vec = topo.get(); if (!tree.same(0, N) || !visited[N]) { cout << 0 << endk; }else if (SZ(vec) != N + 1) { cout << "INF" << endk; } else { reverse(ALL(vec)); V dp(N + 1); V cnt(N + 1, 0); cnt[N] = 1; for (lint v : vec) { for (auto nxt : rev[v]) { dp[nxt.first] += dp[v] * nxt.second.second + (cnt[v] * nxt.second.second) * nxt.second.first; cnt[nxt.first] += cnt[v] * nxt.second.second; } } ModInt ans = 0; cout << dp[0].a << endk; } }