//看看会不会爆int!数组会不会少了一维！
//取物问题一定要小心先手胜利的条件
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker,"/STACK:102400000,102400000")
#define LL long long
#define ALL(a) a.begin(), a.end()
#define pb push_back
#define mk make_pair
#define fi first
#define se second
#define haha printf("haha\n")
const int maxn = 1e5 + 5;
const LL inf = 1e16;
int n, q, s;
vector<pair<int, LL> > one[maxn];
vector<pair<pair<int, int>, LL> > er[maxn], san[maxn];
///tree保存目前节点能往右边延伸到的最右端，que保存目前节点的最小值
int tree[maxn << 2];
pair<LL, int> que[maxn << 2];
LL lazy[maxn << 2];
LL d[maxn];

inline void update_queue(int o, LL val){
    if (que[o].fi == inf + 1) return;
    que[o].fi = min(que[o].fi, val);
    if (lazy[o] == -1) lazy[o] = val;
    lazy[o] = min(lazy[o], val);
}

void push_down(int o){
    int lb = o << 1, rb = o << 1 | 1;
    if (lazy[o] != -1){
        update_queue(lb, lazy[o]);
        update_queue(rb, lazy[o]);
        lazy[o] = -1;
    }
}
/*
因为对于第二种情况：v->[l,r]来说，[l,r]的值是相同的，所以我们就假定按照优先级来计算即可
对于第三种情况：[l, r]->v来说，[l,r]中只能是最小的那个点到v，因为只有这样才能保证最短
*/
void update(int ql, int qr, int l, int r, int o, LL val){
    //printf("ql = %d qr = %d l = %d r = %d\n", ql, qr, l, r);
    if (ql <= l && qr >= r){
        if (val == inf + 1) que[o] = mk(val, l);
        else update_queue(o, val);
        return ;
    }
    push_down(o);
    int mid = (l + r) / 2;
    if (ql <= mid) update(ql, qr, l, mid, o << 1, val);
    if (qr > mid) update(ql, qr, mid + 1, r, o << 1 | 1, val);
    que[o] = min(que[o << 1], que[o << 1 | 1]);
   // printf("que[%d] = %lld %d val = %lld\n", o, que[o], val);
}

vector<pair<int, LL> > ve;
void find_point(int x, int l, int r, int o){
    if (l > x || tree[o] < x) return ;
    if (l == r){
        while (!san[l].empty() && san[l].back().fi.fi >= x){
            ve.push_back(mk(san[l].back().fi.se, san[l].back().se));
            san[l].pop_back();
        }
        tree[o] = -1;
        if (!san[l].empty()) tree[o] = san[l].back().fi.fi;
        return ;
    }
    int mid = (l + r) / 2;
    find_point(x, l, mid, o << 1);
    find_point(x, mid + 1, r, o << 1 | 1);
    tree[o] = max(tree[o << 1], tree[o << 1 | 1]);
}

void solve(){
    for (int i = 1; i <= n; i++) d[i] = inf;
    update(s, s, 1, n, 1, 0);///更新初始点
    while (true){
        int u = que[1].se;
        LL cost = que[1].fi;
        if (cost == inf + 1) break;
        d[u] = min(cost, d[u]);
        update(u, u, 1, n, 1, inf + 1);///如果从队列里面访问过了，就不需要再访问了
        ///第一种，单点更新u->v
        for (int i = 0; i < one[u].size(); i++){
            int v = one[u][i].fi; LL w = one[u][i].se;
            update(v, v, 1, n, 1, d[u] + w);
        }
        ///第二种，成段更新，u->[l,r]
        for (int i = 0; i < er[u].size(); i++){
            int ql = er[u][i].fi.fi, qr = er[u][i].fi.se; LL w = er[u][i].se;
            update(ql, qr, 1, n, 1, d[u] + w);
        }
        ///第三种，单点更新，[l, r]->v，其中[l,r]包含了u节点
        ve.clear();
        find_point(u, 1, n, 1);
        for (int i = 0; i < ve.size(); i++){
            int v = ve[i].fi; LL w = ve[i].se;
            update(v, v, 1, n, 1, d[u] + w);
        }
    }
    for (int i = 1; i <= n; i++){
        if (d[i] == inf) printf("-1 ");
        else printf("%lld ", d[i]);
    }
    cout << endl;
}

void build(int l, int r, int o){
    if (l == r){
        que[o] = mk(inf, l);
        tree[o] = -1;
        if (!san[l].empty()) tree[o] = san[l].back().fi.fi;
        return ;
    }
    int mid = (l + r) / 2;
    if (l <= mid) build(l, mid, o << 1);
    if (r > mid) build(mid + 1, r, o << 1 | 1);
    tree[o] = max(tree[o << 1], tree[o << 1 | 1]);
    que[o] = min(que[o << 1], que[o << 1 | 1]);
}

int main(){
    cin >> n >> q >> s;
    for (int i = 1; i <= q; i++){
        int ty; scanf("%d", &ty);
        if (ty == 1){
            int u, v; LL val; scanf("%d%d%lld", &u, &v, &val);
            one[u].pb(mk(v, val));
        }
        else {
            int u, l, r; LL val; scanf("%d%d%d%lld", &u, &l, &r, &val);
            if (ty == 2) er[u].pb(mk(mk(l, r), val));
            else san[l].pb(mk(mk(r, u), val));
        }
    }
    for (int i = 1; i <= n; i++) sort(ALL(san[i]));
    memset(lazy, -1, sizeof(lazy));
    build(1, n, 1);
    solve();
    return 0;
}