//In the name of God

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
#include<deque>
#include<set>
#include<map>
#include<string>
#include<cstring>
#include<utility>
#include<iomanip>
using namespace std;


typedef long long ll;
typedef pair<int, int> pii;

template<class P, class Q> inline P smin(P &a, Q b) { if (b < a) a = b; return a; }
template<class P, class Q> inline P smax(P &a, Q b) { if (a < b) a = b; return a; }

#define rep(i, n) for (int i = 0, _n = (int)(n); i < _n; i++)

const int N = 5e4 + 5, K = 11;

int read() { int x; cin >> x; return x; }

vector<int> ed[K][N << 2], adj[K][N];
set<int> rem[K];
int n, k, m, mark[K][N], sl[N], sr[N], tl[N], tr[N], len[N], d[K][N], belong[K][N], vis[K][N];
set<pair<int, pair<int, int> > > st;
void push(int i, int j, int x, int g, int v = 1, int b = 0, int e = n) {
    if (i >= e || b >= j)
        return;
    if (i <= b && e <= j) {
        ed[g][v].push_back(x);
        return;
    }
    int m = b + e >> 1, l = v << 1, r = l | 1;
    push(i, j, x, g, l, b, m);
    push(i, j, x, g, r, m, e);
}

void get_edges(int p, int g, int v = 1, int b = 0, int e = n) {    
    int m = b + e >> 1, l = v << 1, r = l | 1;
    if (b + 1 != e) {
        if (p < m)
            get_edges(p, g, l, b, m);
        else
            get_edges(p, g, r, m, e);
    }
    while ((int) ed[g][v].size() > 0) {
        int id = ed[g][v].back();
        ed[g][v].pop_back();
        if (!mark[g][id]) {
            belong[g][id] = p;
            mark[g][id] = 1;
            adj[g][p].push_back(id);
        }
    }
}

void relax(int v, int g) {
    get_edges(v, g);
    rep(i, (int) adj[g][v].size()) {
        int id = adj[g][v][i], w = len[id];
        st.insert(make_pair(d[g][v] + w, make_pair(g, id)));
        if (g != k) {
            while (true) {
                set<int> :: iterator it = rem[g + 1].lower_bound(tl[id]);
                if (it == rem[g + 1].end() || (*it) >= tr[id])
                    break;
                d[g + 1][*it] = d[g][v];
                rem[g + 1].erase(it);
                relax(*it, g + 1);
            } 
        }
    }
}

int main() {
    ios_base :: sync_with_stdio(false); cin.tie(0); cout.tie(0);
    read();
    n = read(), m = read(), k = read();
    rep(i, m) {
        int x = 2 * i, y = 2 * i + 1;
        sl[x] = read() - 1;
        sr[x] = read();
        tl[x] = read() - 1;
        tr[x] = read();
        tl[y] = sl[x];
        tr[y] = sr[x];
        sl[y] = tl[x];
        sr[y] = tr[x];
        len[x] = read();
        len[y] = len[x];
        rep(aa, 2)
            rep(g, k + 1)
                push(sl[i * 2 + aa], sr[i * 2 + aa], i * 2 + aa, g);
    }
    memset(d, 63, sizeof d);
    d[0][0] = 0;
    rep(i, n)
        rep(j, k + 1)
            rem[j].insert(i);
    rem[0].erase(0);
    relax(0, 0);
    while ((int) st.size()) {
        pair<int, pair<int, int> > cur = *(st.begin());
        st.erase(st.begin());
        int dis = cur.first, g = cur.second.first, id = cur.second.second, v = belong[g][id];
        if (vis[g][id]++)
            continue;
//        relax(v, g);
        while (true) {
            set<int> :: iterator it = rem[g].lower_bound(tl[id]);
            if (it == rem[g].end() || *it >= tr[id])
                break;
            int u = *it;
            rem[g].erase(it);
            d[g][u] = dis;
            relax(u, g);
        } 
    }
    int res = 2e9;
    rep(i, k + 1)
        res = min(res, d[i][n - 1]);
    if (res >= 1e9)
        cout << "CreationAugust is a sb!" << '\n';
    else
        cout << res << '\n';
}