#include <bits/stdc++.h>
using namespace std;
class Edge {
 public:
  int to, next;
  long long cost;
  Edge(int t, int n, long long c) : to(t), next(n), cost(c) {}
  Edge() : to(-1), next(-1), cost(0) {}
};
void add_edge(int u, int v, long long w);
void add_edge_DAG(int u, int v, long long w);
long long get_limit(long long w);
long long get_sum(long long w);
void get_scc();
void tarjan(int u, stack<int> &s);
long long solve(int s);
const long long NAGINF = 0xbfbfbfbf;
const int MAXN = 1e6 + 5, MAXM = 1e6 + 5;
Edge edges[MAXM];
int head[MAXN];
int esize;
Edge edges_DAG[MAXM];
int head_DAG[MAXN];
int esize_DAG;
int dfn[MAXN], low[MAXN], belong[MAXN], dfcnt, scc;
int degree[2][MAXN];
long long sum[MAXN], dist[MAXN];
int n;
int main() {
  int m, s;
  while (scanf("%d %d", &n, &m) != EOF) {
    memset(head, -1, sizeof(head));
    esize = 0;
    memset(dfn, -1, sizeof(dfn));
    memset(low, -1, sizeof(low));
    memset(belong, -1, sizeof(belong));
    dfcnt = 0;
    memset(head_DAG, -1, sizeof(head_DAG));
    esize_DAG = 0;
    memset(degree, 0, sizeof(degree));
    memset(sum, 0, sizeof(sum));
    int x, y;
    long long w;
    while (m--) {
      scanf("%d %d %lld", &x, &y, &w);
      add_edge(x, y, w);
    }
    scanf("%d", &s);
    get_scc();
    for (int u = 1; u <= n; u++)
      for (int i = head[u]; i != -1; i = edges[i].next) {
        int v = edges[i].to;
        if (belong[u] == belong[v]) {
          sum[belong[u]] += get_limit(edges[i].cost);
        }
      }
    for (int u = 1; u <= n; u++)
      for (int i = head[u]; i != -1; i = edges[i].next) {
        int v = edges[i].to;
        if (belong[u] != belong[v]) {
          add_edge_DAG(belong[u], belong[v], edges[i].cost + sum[belong[v]]);
        }
      }
    long long res = solve(belong[s]);
    printf("%lld\n", res);
  }
  return 0;
}
void add_edge(int u, int v, long long w) {
  edges[esize].to = v;
  edges[esize].next = head[u];
  edges[esize].cost = w;
  head[u] = esize;
  esize++;
}
void add_edge_DAG(int u, int v, long long w) {
  edges_DAG[esize_DAG].to = v;
  edges_DAG[esize_DAG].next = head_DAG[u];
  edges_DAG[esize_DAG].cost = w;
  head_DAG[u] = esize_DAG;
  esize_DAG++;
}
long long get_limit(long long cost) {
  long long left = 1, right = 1e5;
  long long ans = 0;
  while (left <= right) {
    long long mid = (left + right) / 2;
    long long sum = (1 + mid) * mid / 2;
    if (sum < cost) {
      ans = mid;
      left = mid + 1;
    } else {
      right = mid - 1;
    }
  }
  return (cost + ans * cost - get_sum(ans));
}
inline long long get_sum(long long n) {
  long long sum = n * (n + 1) * (n + 2) / 6;
  return sum;
}
void get_scc() {
  scc = 0;
  stack<int> s;
  for (int i = 1; i <= n; i++) {
    if (dfn[i] == -1) {
      tarjan(i, s);
    }
  }
  for (int u = 1; u <= n; u++)
    for (int i = head[u]; i != -1; i = edges[i].next) {
      int v = edges[i].to;
      if (belong[u] != belong[v]) {
        degree[0][belong[v]]++;
        degree[1][belong[u]]++;
      }
    }
}
void tarjan(int u, stack<int> &s) {
  dfn[u] = low[u] = ++dfcnt;
  s.push(u);
  for (int i = head[u]; i != -1; i = edges[i].next) {
    int v = edges[i].to;
    if (dfn[v] == -1) {
      tarjan(v, s);
      low[u] = min(low[u], low[v]);
    } else if (belong[v] == -1) {
      low[u] = min(low[u], dfn[v]);
    }
  }
  if (dfn[u] == low[u]) {
    scc++;
    while (!s.empty()) {
      int v = s.top();
      s.pop();
      belong[v] = scc;
      if (u == v) break;
    }
  }
}
long long solve(int s) {
  memset(dist, NAGINF, sizeof(dist));
  dist[s] = sum[s];
  queue<int> q;
  for (int i = 1; i <= scc; i++) {
    if (degree[0][i] == 0) q.push(i);
  }
  while (!q.empty()) {
    int u = q.front();
    q.pop();
    for (int i = head_DAG[u]; i != -1; i = edges_DAG[i].next) {
      int v = edges_DAG[i].to;
      if (dist[u] != NAGINF) {
        dist[v] = max(dist[v], dist[u] + edges_DAG[i].cost);
      }
      if (--degree[0][v] == 0) q.push(v);
    }
  }
  long long res = 0;
  for (int i = 1; i <= scc; i++) {
    res = max(res, dist[i]);
  }
  return res;
}
