似乎由于栈深度的限制，Java用递归的tarjan来做此题会导致栈溢出，至少目前还没看到Java通过的提交记录，当然本蒟蒻也不清楚具体是为什么，如果有大佬ac了轻喷

import java.util.*;
import java.io.*;

public class Main {
    static StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

    static int in() throws IOException {
        st.nextToken();
        return (int) st.nval;
    }

    static double nextDouble() throws IOException {
        st.nextToken();
        return st.nval;
    }

    static final int N = 80010;
    static final int M = 200050;
    static int n, m, t, cnt, tot, T, s, ans;
    static int[] head = new int[N];
    static int[] dfn = new int[N];
    static int[] low = new int[N];
    static int[] vis = new int[N];
    static int[] col = new int[N];
    static int[] H = new int[N];
    static int[] sum = new int[N];
    static int[] dis = new int[N];
    static int[] V = new int[N];
    static edge[] e = new edge[M];
    static edge[] E = new edge[M];
    static Stack<Integer> stack = new Stack<>();
    static Queue<Integer> q = new LinkedList<>();

    static class edge {
        int from, to, next, val, k;

        public edge(int from, int to, int next, int val, int k) {
            this.from = from;
            this.to = to;
            this.next = next;
            this.val = val;
            this.k = k;
        }
    }

    static void addedge(int u, int v, int w, int k) {
        e[++t] = new edge(u, v, head[u], w, k);
        head[u] = t;
    }

    static void add(int u, int v, int w) {
        E[++T] = new edge(u, v, H[u], w, 0);
        H[u] = T;
    }

    static void tarjan(int u) {
        dfn[u] = low[u] = ++cnt;
        vis[u] = 1;
        stack.push(u);
        for (int i = head[u]; i != 0; i = e[i].next) {
            int v = e[i].to;
            if (dfn[v] == 0) {
                tarjan(v);
                low[u] = Math.min(low[u], low[v]);
            } else if (vis[v] != 0) {
                low[u] = Math.min(low[u], dfn[v]);
            }
        }
        if (dfn[u] == low[u]) {
            tot++;
            int v;
            do {
                v = stack.pop();
                col[v] = tot;
                vis[v] = 0;
            } while (v != u);
        }
    }

    static void spfa(int s) {
        Arrays.fill(dis, -1);
        Arrays.fill(V, 0);
        dis[s] = sum[s];
        V[s] = 1;
        q.add(s);
        while (!q.isEmpty()) {
            int u = q.poll();
            V[u] = 0;
            for (int i = H[u]; i != 0; i = E[i].next) {
                int v = E[i].to;
                int w = E[i].val;
                if (dis[v] < dis[u] + w + sum[v]) {
                    dis[v] = dis[u] + w + sum[v];
                    if (V[v] == 0) {
                        V[v] = 1;
                        q.add(v);
                    }
                }
            }
        }
    }

    public static void main(String[] args) throws IOException {
        n = in();
        m = in();
        for (int i = 1; i <= m; i++) {
            int x = in();
            int y = in();
            int z = in();
            double k = nextDouble();
            addedge(x, y, z, (int) (k * 10));
        }
        for (int i = 1; i <= n; i++) {
            if (dfn[i] == 0) {
                tarjan(i);
            }
        }
        for (int i = 1; i <= m; i++) {
            int x = e[i].from;
            int y = e[i].to;
            int z = e[i].val;
            int k = e[i].k;
            if (col[x] == col[y]) {
                while (z > 0) {
                    sum[col[x]] += z;
                    z = z * k / 10;
                }
            } else {
                add(col[x], col[y], z);
            }
        }
        s = in();
        s = col[s];
        spfa(s);
        for (int i = 1; i <= tot; i++) {
            ans = Math.max(ans, dis[i]);
        }
        out.println(ans);
        out.close();
    }
}