// #pragma GCC target("avx2") // #pragma GCC optimize("O3") // #pragma GCC optimize("unroll-loops") #include using namespace std; using ll = long long; using ld = long double; using pll = pair; using pii = pair; using vvl = vector>; using vvi = vector>; using vvpll = vector>; #define rep(i, a, b) for (ll i=(a); i<(b); i++) #define rrep(i, a, b) for (ll i=(a); i>(b); i--) #define pb push_back #define tostr to_string #define ALL(A) A.begin(), A.end() #define elif else if // constexpr ll INF = LONG_LONG_MAX; constexpr ll INF = 1e18; constexpr ll MOD = 1000000007; const string digits = "0123456789"; const string ascii_lowercase = "abcdefghijklmnopqrstuvwxyz"; const string ascii_uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; const string ascii_letters = ascii_lowercase + ascii_uppercase; template vector> list2d(int N, int M, T init) { return vector>(N, vector(M, init)); } template vector>> list3d(int N, int M, int L, T init) { return vector>>(N, vector>(M, vector(L, init))); } template vector>>> list4d(int N, int M, int L, int O, T init) { return vector>>>(N, vector>>(M, vector>(L, vector(O, init)))); } vector LIST(ll N) { vector A(N); rep(i, 0, N) cin >> A[i]; return A; } void print(ld out) { cout << fixed << setprecision(15) << out << '\n'; } void print(double out) { cout << fixed << setprecision(15) << out << '\n'; } template void print(T out) { cout << out << '\n'; } template void print(pair out) { cout << out.first << ' ' << out.second << '\n'; } template void print(vector A) { rep(i, 0, A.size()) { cout << A[i]; cout << (i == A.size()-1 ? '\n' : ' '); } } template void print(set S) { vector A(S.begin(), S.end()); print(A); } void Yes() { print("Yes"); } void No() { print("No"); } void YES() { print("YES"); } void NO() { print("NO"); } ll floor(ll a, ll b) { if (a < 0) { return (a-b+1) / b; } else { return a / b; } } ll ceil(ll a, ll b) { if (a >= 0) { return (a+b-1) / b; } else { return a / b; } } pll divmod(ll a, ll b) { ll d = a / b; ll m = a % b; return {d, m}; } template bool chmax(T &x, T y) { return (y > x) ? x = y, true : false; } template bool chmin(T &x, T y) { return (y < x) ? x = y, true : false; } template T sum(vector A) { T res = 0; for (T a: A) res += a; return res; } template T max(vector A) { return *max_element(ALL(A)); } template T min(vector A) { return *min_element(ALL(A)); } ll toint(string s) { ll res = 0; for (char c : s) { res *= 10; res += (c - '0'); } return res; } int toint(char num) { return num - '0'; } char tochar(int num) { return '0' + num; } int ord(char c) { return (int)c; } char chr(int a) { return (char)a; } ll pow(ll x, ll n) { ll res = 1; rep(_, 0, n) res *= x; return res; } ll pow(ll x, ll n, int mod) { ll res = 1; while (n > 0) { if (n & 1) { res = (res * x) % mod; } x = (x * x) % mod; n >>= 1; } return res; } int popcount(ll S) { return __builtin_popcountll(S); } ll gcd(ll a, ll b) { return __gcd(a, b); } ll lcm(ll x, ll y) { return (x * y) / gcd(x, y); } template int bisect_left(vector &A, T val) { return lower_bound(ALL(A), val) - A.begin(); } template int bisect_right(vector &A, T val) { return upper_bound(ALL(A), val) - A.begin(); } #include #include #include #include #include #include #include #include namespace atcoder { namespace internal { template struct csr { std::vector start; std::vector elist; csr(int n, const std::vector>& edges) : start(n + 1), elist(edges.size()) { for (auto e : edges) { start[e.first + 1]++; } for (int i = 1; i <= n; i++) { start[i] += start[i - 1]; } auto counter = start; for (auto e : edges) { elist[counter[e.first]++] = e.second; } } }; } // namespace internal } // namespace atcoder #include #include #include #include #include #include namespace atcoder { namespace internal { struct scc_graph { public: scc_graph(int n) : _n(n) {} int num_vertices() { return _n; } void add_edge(int from, int to) { edges.push_back({from, {to}}); } std::pair> scc_ids() { auto g = csr(_n, edges); int now_ord = 0, group_num = 0; std::vector visited, low(_n), ord(_n, -1), ids(_n); visited.reserve(_n); auto dfs = [&](auto self, int v) -> void { low[v] = ord[v] = now_ord++; visited.push_back(v); for (int i = g.start[v]; i < g.start[v + 1]; i++) { auto to = g.elist[i].to; if (ord[to] == -1) { self(self, to); low[v] = std::min(low[v], low[to]); } else { low[v] = std::min(low[v], ord[to]); } } if (low[v] == ord[v]) { while (true) { int u = visited.back(); visited.pop_back(); ord[u] = _n; ids[u] = group_num; if (u == v) break; } group_num++; } }; for (int i = 0; i < _n; i++) { if (ord[i] == -1) dfs(dfs, i); } for (auto& x : ids) { x = group_num - 1 - x; } return {group_num, ids}; } std::vector> scc() { auto ids = scc_ids(); int group_num = ids.first; std::vector counts(group_num); for (auto x : ids.second) counts[x]++; std::vector> groups(ids.first); for (int i = 0; i < group_num; i++) { groups[i].reserve(counts[i]); } for (int i = 0; i < _n; i++) { groups[ids.second[i]].push_back(i); } return groups; } private: int _n; struct edge { int to; }; std::vector> edges; }; } // namespace internal } // namespace atcoder namespace atcoder { struct scc_graph { public: scc_graph() : internal(0) {} scc_graph(int n) : internal(n) {} void add_edge(int from, int to) { int n = internal.num_vertices(); assert(0 <= from && from < n); assert(0 <= to && to < n); internal.add_edge(from, to); } std::vector> scc() { return internal.scc(); } private: internal::scc_graph internal; }; } // namespace atcoder using namespace atcoder; vector bfs(vvi &nodes, int src) { int N = nodes.size(); vector res(N, -1); queue que; res[src] = 0; que.push(src); while(!que.empty()) { int u = que.front(); que.pop(); for (auto v: nodes[u]) { if (res[v] == -1) { res[v] = res[u]+1; que.push(v); } } } return res; } int main() { cin.tie(0); ios::sync_with_stdio(false); ll N, M; cin >> N >> M; N++; vvi nodes(N), nodesrev(N); vector> edges; rep(i, 0, M) { ll u, v, l, a; cin >> u >> v >> l >> a; nodes[u].pb(v); nodesrev[v].pb(u); edges.pb({u, v, l*a}); } auto res = bfs(nodes, 0); auto resrev = bfs(nodesrev, N-1); set need; rep(i, 0, N) { if (res[i] != -1 and resrev[i] != -1) { need.insert(i); } } vvpll nodes2(N); scc_graph scc(N); for (auto& [u, v, c] : edges) { if (need.count(u) and need.count(v)) { nodes2[u].pb({v, c}); scc.add_edge(u, v); } } auto groups = scc.scc(); vector dp(N); dp[0] = 1; for (auto &group : groups) { if (group.size() >= 2) { print("INF"); return 0; } for (ll u : group) { for (auto [v, c] : nodes2[u]) { dp[v] += dp[u]*c; dp[v] %= MOD; } } } ll ans = dp[N-1]; print(ans); return 0; }