#line 2 "template/template.hpp"
using namespace std;

#include<bits/stdc++.h>
#line 1 "template/inout.hpp"
namespace noya2 {

template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
  os << p.first << " " << p.second;
  return os;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
  is >> p.first >> p.second;
  return is;
}

template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
  int s = (int)v.size();
  for (int i = 0; i < s; i++) os << (i ? " " : "") << v[i];
  return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
  for (auto &x : v) is >> x;
  return is;
}

void in() {}
template <typename T, class... U>
void in(T &t, U &...u) {
  cin >> t;
  in(u...);
}

void out() { cout << "\n"; }
template <typename T, class... U, char sep = ' '>
void out(const T &t, const U &...u) {
  cout << t;
  if (sizeof...(u)) cout << sep;
  out(u...);
}

struct IoSetup {
  IoSetup() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(15);
    cerr << fixed << setprecision(7);
  }
} iosetup_noya2;

}  // namespace noya2
#line 1 "template/const.hpp"
namespace noya2{

const int iinf = 1'000'000'007;
const long long linf = 2'000'000'000'000'000'000LL;
const long long mod998 =  998244353;
const long long mod107 = 1000000007;
const long double pi = 3.14159265358979323;
const vector<int> dx = {0,1,0,-1,1,1,-1,-1};
const vector<int> dy = {1,0,-1,0,1,-1,-1,1};
const string ALP = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const string alp = "abcdefghijklmnopqrstuvwxyz";
const string NUM = "0123456789";

void yes(){ cout << "Yes\n"; }
void no(){ cout << "No\n"; }
void YES(){ cout << "YES\n"; }
void NO(){ cout << "NO\n"; }
void yn(bool t){ t ? yes() : no(); }
void YN(bool t){ t ? YES() : NO(); }

} // namespace noya2
#line 1 "template/utils.hpp"
namespace noya2{

unsigned long long inner_binary_gcd(unsigned long long a, unsigned long long b){
    if (a == 0 || b == 0) return a + b;
    int n = __builtin_ctzll(a);
    int m = __builtin_ctzll(b);
    a >>= n;
    b >>= m;
    while (a != b) {
        int m = __builtin_ctzll(a - b);
        bool f = a > b;
        unsigned long long c = f ? a : b;
        b = f ? b : a;
        a = (c - b) >> m;
    }
    return a << min(n, m);
}

template<typename T>
T gcd_fast(T a, T b){
    return static_cast<T>(inner_binary_gcd(abs(a),abs(b)));
}

template<typename T>
T floor_div(const T n, const T d) {
    assert(d != 0);
    return n / d - static_cast<T>((n ^ d) < 0 && n % d != 0);
}

template<typename T>
T ceil_div(const T n, const T d) {
    assert(d != 0);
    return n / d + static_cast<T>((n ^ d) >= 0 && n % d != 0);
}

template<typename T> void uniq(vector<T> &v){
    sort(all(v));
    v.erase(unique(all(v)),v.end());
}

template <typename T, typename U>
inline bool chmin(T &x, U y) {
    return (y < x) ? (x = y, true) : false;
}

template <typename T, typename U>
inline bool chmax(T &x, U y) {
    return (x < y) ? (x = y, true) : false;
}

template<typename T>
inline bool range(T l, T x, T r){
    return l <= x && x < r;
}

} // namespace noya2
#line 8 "template/template.hpp"

#define rep(i,n) for (int i = 0; i < (int)(n); i++)
#define repp(i,m,n) for (int i = (m); i < (int)(n); i++)
#define reb(i,n) for (int i = (int)(n-1); i >= 0; i--)
#define all(v) (v).begin(),(v).end()

using ll = long long;
using ld = long double;
using uint = unsigned int;
using ull = unsigned long long;
using pii = pair<int,int>;
using pll = pair<ll,ll>;
using pil = pair<int,ll>;
using pli = pair<ll,int>;

namespace noya2{

/*　~ (. _________ . /)　*/

}

using namespace noya2;


#line 2 "c.cpp"

#line 2 "graph/Graph_core.hpp"

#line 4 "graph/Graph_core.hpp"

namespace noya2 {

struct naiveGraph { // undirected unweighted tree
    naiveGraph (int _n = 0) : n(_n){
        es0.resize(n);
        es1.resize(n);
        _vis.resize(n,0);
    }
    void add_edge(int u, int v, bool undirect = true, int id = -1){
        es0[u].emplace_back(v);
        es1[u].emplace_back(v,id);
        if (undirect){
            es0[v].emplace_back(u);
            es1[v].emplace_back(u,id);
        }
    }
    void input(int m, int _indexed = 1, bool undirect = true){
        rep(i,m){
            int u, v; in(u,v);
            u -= _indexed;
            v -= _indexed;
            add_edge(u,v,undirect,i);
        }
    }
    bool yet(int v){ return _vis[v] == 0; }
    void visit(int v) { _vis[v]++; }
    void reset(int v = -1){ 
        if (v == -1) fill(all(_vis),0);
        else _vis[v] = 0;
    }
    const vector<int>& operator[](int idx) const { return es0[idx]; }
    const vector<pair<int,int>>& operator()(int idx) const {return es1[idx]; }
  private:
    int n;
    vector<vector<int>> es0;
    vector<vector<pair<int,int>>> es1;
    vector<int> _vis;
};

struct usefulGraph { // directed weighted graph
    usefulGraph (int _n = 0) : n(_n){
        es.resize(n);
        _vis.resize(n,0);
    }
    void add_edge(int u, int v, bool undirect = true, ll cost = 1){
        es[u].emplace_back(v,cost);
        if (undirect){
            es[v].emplace_back(u,cost);
        }
    }
    void input(int m, int _indexed = 1, bool undirect = true){
        rep(i,m){
            int u, v; in(u,v);
            ll cost; in(cost);
            u -= _indexed;
            v -= _indexed;
            add_edge(u,v,undirect,cost);
        }
    }
    bool yet(int v){ return _vis[v] == 0; }
    void visit(int v) { _vis[v]++; }
    void reset(int v = -1){ 
        if (v == -1) fill(all(_vis),0);
        else _vis[v] = 0;
    }
    vector<ll> dijkstra(int s){ // all edge weight >= 0
        vector<ll> dist(n,linf);
        dist[s] = 0LL;
        priority_queue<pli,vector<pli>,greater<pli>> pque;
        pque.push(pli(0,s));
        while (!pque.empty()){
            auto [d, f] = pque.top(); pque.pop();
            if (dist[f] < d) continue;
            for (auto [t, cost] : es[f]){
                if (chmin(dist[t],d+cost)){
                    pque.push(pli(dist[t],t));
                }
            }
        }
        return dist;
    }
    vector<int> reconstruct(int s, int t, const vector<ll> &dist){
        if (dist[t] == linf) return {};
        vector<int> froms(n,-1);
        queue<int> que;
        que.push(s);
        froms[s] = s;
        while (!que.empty()){
            int v = que.front(); que.pop();
            for (auto [u, cost] : es[v]){
                if (froms[u] == -1 && dist[v] + cost == dist[u]){
                    froms[u] = v;
                    que.push(u);
                }
            }
        }
        vector<int> ans = {t};
        while (t != s){
            t = froms[t];
            ans.emplace_back(t);
        }
        reverse(all(ans));
        return ans;
    }
    vector<ll> bfs01(int s){ // all edge weight = 0 or 1
        vector<ll> dist(n,linf);
        dist[s] = 0;
        deque<int> que;
        que.push_back(s);
        while (!que.empty()){
            auto f = que.front(); que.pop_front();
            for (auto [t, cost] : es[f]){
                if (chmin(dist[t],dist[f]+cost)){
                    if (cost == 0) que.push_front(t);
                    else que.push_back(t);
                }
            }
        }
        return dist;
    }
    vector<ll> bellman_ford(int s, bool &ng_cycle){
        vector<ll> dist(n,linf);
        vector<int> ng;
        dist[s] = 0;
        int tm = 0;
        while (tm < n){
            bool finish = true;
            for (int f = 0; f < n; f++){
                if (dist[f] == linf) continue;
                for (auto [t, cost] : es[f]){
                    if (chmin(dist[t],dist[f]+cost)){
                        finish = false;
                        if (tm == n-1) ng.emplace_back(t);
                    }
                }
            }
            if (finish) break;
            tm++;
        }
        ng_cycle = (tm == n);
        if (ng_cycle){
            for (auto v : ng) dist[v] = -linf;
            tm = n;
            while (tm--){
                for (int f = 0; f < n; f++){
                    if (dist[f] != -linf) continue;
                    for (auto e : es[f]){
                        dist[e.first] = -linf;
                    }
                }
            }
        }
        return dist;
    }
    vector<vector<ll>> warshall_floyd(){
        vector<vector<ll>> res(n,vector<ll>(n,linf));
        rep(i,n){
            res[i][i] = 0;
            for (auto [t, cost] : es[i]){
                chmin(res[i][t],cost);
            }
        }
        rep(k,n) rep(i,n) rep(j,n){
            chmin(res[i][j],res[i][k]+res[k][j]);
        }
        return res;
    }
    const vector<pair<int,ll>>& operator[](int idx) const { return es[idx]; }
  private:
    int n;
    vector<vector<pair<int,ll>>> es;
    vector<int> _vis;
};

} // namespace noya2
#line 4 "c.cpp"

void solve(){
    int n, m; in(n,m);
    ll x; in(x);
    naiveGraph g(n);
    vector<ll> a(m), b(m);
    rep(i,m){
        int u, v; in(u,v,a[i],b[i]); u--, v--;
        g.add_edge(u,v,true,i);
    }
    auto check = [&](ll w){
        vector<ll> dist(n,linf);
        dist[0] = 0;
        priority_queue<pli,vector<pli>,greater<pli>> pque;
        pque.push(pli(0,0));
        while (!pque.empty()){
            auto [d, f] = pque.top(); pque.pop();
            if (dist[f] < d) continue;
            for (auto [t, i] : g(f)){
                if (b[i] < w) continue;
                if (chmin(dist[t],d+a[i])){
                    pque.push(pli(dist[t],t));
                }
            }
        }
        return dist[n-1] <= x;
    };
    ll le = -1, ri = iinf;
    while (ri - le > 1){
        ll md = (le + ri) / 2;
        if (check(md)) le = md;
        else ri = md;
    }
    out(le);
}

int main(){
    int t = 1; //in(t);
    while (t--) { solve(); }
}