#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 5; 
const int M = 2e5 + 5; 
const int INF = 1e9; 

int n, m, vis[N]; 
double ET, dn[N]; 
struct Edge { int v; double w; int id; Edge(int v = 0, double w = 0, int id = 0) : v(v), w(w), id(id) {} }; 
vector<Edge> G[N], E[N]; 

void init(void) {
    #define pii pair<double, int>
    priority_queue<pii, vector<pii>, greater<pii>> q; 
    for (int i = 1; i <= n; ++i) dn[i] = INF; 
    q.emplace(dn[n] = 0, n); 
    while (!q.empty()) {
        int u = q.top().second; q.pop(); 
        if (vis[u]) continue; vis[u] = 1; 
        for (auto [v, w, id] : E[u]) if (dn[v] > dn[u] + w) q.emplace(dn[v] = dn[u] + w, v); 
    }
    if (dn[1] >= INF) cout << "0\n", exit(0); 
    if (dn[1] >= ET) cout << "1\n", exit(0); 
}

int fa[N]; 
bool tree[M]; 
void dfs(int x) {
    vis[x] = 1; 
    for (auto [y, w, id] : E[x]) if (!vis[y] && dn[y] == dn[x] + w) fa[y] = x, tree[id] = 1, dfs(y); 
}

struct Node {
    int x; double v; 
    Node(int x = 0, double v = 0) : x(x), v(v) {}
    bool operator> (const Node &a) const {
        return v > a.v; 
    }
}; 
int ls[M * 20], rs[M * 20], d[M * 20], tot, rt[N]; 
Node val[M * 20]; 
int newNode(Node w) { return val[++tot] = w, tot; }
int merge(int x, int y) {
    if (!x || !y) return x + y; 
    if (val[x] > val[y]) swap(x, y); 
    int p = ++tot; val[p] = val[x]; ls[p] = ls[x]; 
    rs[p] = merge(rs[x], y); 
    if (d[ls[p]] < d[rs[p]]) swap(ls[p], rs[p]); 
    d[p] = d[rs[p]] + 1; 
    return p; 
}

void dfs2(int x) {
    vis[x] = 1; 
    if (fa[x]) rt[x] = merge(rt[x], rt[fa[x]]); 
    for (auto [y, w, id] : E[x]) if (fa[y] == x && !vis[y]) dfs2(y); 
}

int main(void) {
    ios::sync_with_stdio(0); 

    cin >> n >> m >> ET; 
    for (int i = 1; i <= m; ++i) {
        int u, v; double w; cin >> u >> v >> w; 
        if (u == n) continue; 
        G[u].emplace_back(v, w, i); 
        E[v].emplace_back(u, w, i); 
    }
    init(); 
    memset(vis, 0, sizeof vis); dfs(n); 

    for (int u = 1; u <= n; ++u) if (dn[u] < INF)
        for (auto [v, w, id] : G[u]) if (!tree[id] && dn[v] < INF)
            rt[u] = merge(rt[u], newNode(Node(v, w - (dn[u] - dn[v])))); 
        
    memset(vis, 0, sizeof vis); dfs2(n); 

    int cnt = 0; 
    priority_queue<pii, vector<pii>, greater<pii>> q; 
    if (rt[1]) q.emplace(dn[1] + val[rt[1]].v, rt[1]); 
    double now = dn[1]; int k = 1; 
    while (!q.empty()) {
        auto [res, x] = q.top(); q.pop(); now += res; 
        if (now > ET) return cout << k << "\n", 0; ++k; 
        if (ls[x]) q.emplace(res - val[x].v + val[ls[x]].v, ls[x]); 
        if (rs[x]) q.emplace(res - val[x].v + val[rs[x]].v, rs[x]); 
        int u = val[x].x; 
        if (rt[u]) q.emplace(res + val[rt[u]].v, rt[u]); 
    }
    cout << k << "\n"; 
    return 0;
}