#include <map>

#include <set>

#include <cmath>

#include <queue>

#include <stack>

#include <vector>

#include <string>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <sstream>

#include <iostream>

#include <algorithm>

#include <functional>

#define For(i, x, y) for(int i=x; i<=y; i++)

#define Mem(f, x) memset(f, x, sizeof(f))

#define Sca(x) scanf("%d", &x)

#define Pri(x) printf("%d\n", x)

#define CLR(u) for(int i = 0; i <= N ; i ++) u[i].clear();

#define LL long long

#define mp make_pair

#define PI pair<int,int>

#define PIL pair<int,long long>

#define PLI pair<long long,int>

#define pb push_back

#define fi first

#define se second

using namespace std;

typedef vector<int> VI;

const int maxn = 1e5 + ;

const int maxm = 3e5 + ;

const LL INF = 1e18 + ;

const int mod = 1e9 + ;

inline int read()

{

    int now=;register char c=getchar();

    for(;!isdigit(c);c=getchar());

    for(;isdigit(c);now=now*+c-'',c=getchar());

    return now;

}

struct Tree

{

    int left,right;

    int lr,rr;

}tree[maxm];

int N,M;

int Q,S;

int tot;

vector<PIL> P[maxm];

LL dis[maxm];

bool vis[maxm];

int Build(int left,int right,int flag)

{

    if(left == right) return left;

    int root = ++tot;

    tree[root].left = left; tree[root].right = right;

    int mid = (left + right) / ;

    tree[root].lr = Build(left,mid,flag);

    tree[root].rr = Build(mid + ,right,flag);

    if(flag){

        P[root].pb(mp(tree[root].lr,));

        P[root].pb(mp(tree[root].rr,));

    }else{

        P[tree[root].lr].pb(mp(root,));

        P[tree[root].rr].pb(mp(root,));

    }

    return root;

}

void update(int v,int l,int r,int root,int flag,LL w)

{

    if(l == r){

        if(flag) P[v].pb(mp(l,w));

        else P[l].pb(mp(v,w));

        return;

    }

    if(l <= tree[root].left && tree[root].right <= r)

    {

        if(flag) P[v].pb(mp(root,w));

        else P[root].pb(mp(v,w));

        return;

    }

    int mid = (tree[root].left + tree[root].right) >> ;

    if(r <= mid) update(v,l,r,tree[root].lr,flag,w);

    else if(l > mid) update(v,l,r,tree[root].rr,flag,w);

    else{

        update(v,l,mid,tree[root].lr,flag,w);

        update(v,mid + ,r,tree[root].rr,flag,w);

    }

}

void Dijkstra(int start){

    Mem(vis,);

    for(int i = ; i <= tot; i ++){

        dis[i] = INF;

    }

    dis[start] = ;

    priority_queue<PLI,vector<PLI>,greater<PLI>>Q;

    Q.push(mp(,start));

    while(!Q.empty()){

        PLI u = Q.top(); Q.pop();

        if(vis[u.se]) continue;

        vis[u.se] = ;

        for(int j =  ; j < P[u.se].size(); j ++){

            PIL v = P[u.se][j];

            if(!vis[v.fi] && dis[v.fi] > dis[u.se] + v.se){

                dis[v.fi] = dis[u.se] + v.se;

                Q.push(mp(dis[v.fi],v.fi));

            }

        }

    }

}

int main()

{

    N = read(); Q = read(); S = read();

    tot = N;

    int L = Build(,N,);

    int R = Build(,N,);

    For(i,,Q){

        int op = read() , v = read();

        LL w;

        if(op == ){

            int u = read();

            scanf("%lld",&w);

            P[v].pb(mp(u,w));

        }else if(op == ){

            int l = read(); int r = read();

            scanf("%lld",&w);

            update(v,l,r,R,,w);

        }else{

            int l = read(); int r = read();

            scanf("%lld",&w);

            update(v,l,r,L,,w);

        }

    }

/*    For(i,N + 1,tot){

    printf("%d   : %d %d\n",i,tree[i].left,tree[i].right);

    }

    For(i,1,tot){

        printf("%d : ",i);

        for(int j = 0 ; j < P[i].size(); j ++){

            printf("%d ",P[i][j]);

        }

        printf("\n");

    } */

    Dijkstra(S);

    For(i,,N){

        if(dis[i] == INF) dis[i] = -;

        printf("%lld ",dis[i]);

    }

    return ;

}