#include <cstdio>

#include <cmath>

#include <cstring>

#include <algorithm>

using namespace std;

const int maxn = 2e5+;

int N,Q,S;

//vector <int> G[maxn];

struct edge{

    int to,next,w;

}e[*maxn];

int head[*maxn],tot;

void add_edge(int u,int v,int w)

{

    e[tot].to = v;

    e[tot].w = w;

    e[tot].next = head[u];

    head[u] = tot++;

    e[tot].to = u;

    e[tot].w = w;

    e[tot].next = head[v];

    head[v] = tot++;

}

int in[maxn],out[maxn],P[*maxn],fa[maxn][],dep[maxn],dis[maxn],cnt;

void dfs(int u,int _fa,int _dep,int _dis)

{

    in[u] = ++cnt;

    P[cnt] = u;

    fa[u][] = _fa;

    dis[u] = _dis;

    dep[u] = _dep;

    for(int i=head[u];~i;i=e[i].next)

    {

        int v = e[i].to;

        if(v == _fa) continue;

        dfs(v,u,_dep+,_dis+e[i].w);

    }

    out[u] = ++cnt;

}

void debug()

{

    printf("in:\t");for(int i=;i<=N;i++) printf("%d ",in[i]);puts("");

    printf("out:\t");for(int i=;i<=N;i++) printf("%d ",out[i]);puts("");

    printf("p:\t");for(int i=;i<=cnt;i++) printf("%d ",P[i]);puts("");

    printf("dis:\t");for(int i=;i<=N;i++) printf("%d ",dis[i]);puts("");

    printf("dep:\t");for(int i=;i<=N;i++) printf("%d ",dep[i]);puts("");

    printf("edge:");for(int i=;i<tot;i++) printf("\tto:%d w:%d\n",e[i].to,e[i].w);

}

int initLCA()

{

    int m = (int)log(N)/log()+;

    for(int k=;k<m;k++)

    {

        for(int v=;v<=N;v++)

        {

            if(fa[v][k] < ) {fa[v][k+] = -;continue;}

            else fa[v][k+] = fa[fa[v][k]][k];

        }

    }

}

int LCA(int u,int v)

{

    int m = (int)log(N)/log()+;

    if(dep[v] > dep[u]) swap(u,v);

    for(int k=;k<m;k++)

    {

        if((dep[u]-dep[v])>>k &  )

            u = fa[u][k];

    }

    if(u == v) return u;

    for(int k=m-;k>=;k--)

    {

        if(fa[u][k] != fa[v][k])

        {

            u = fa[u][k];

            v = fa[v][k];

        }

    }

    return fa[u][];

}

int c[*maxn];

int lowbit(int x) {return x&-x;}

void init()

{

    memset(head,-,sizeof head);

    memset(fa,-,sizeof fa);

    memset(c,,sizeof c);

    memset(in,,sizeof in);

    memset(out,,sizeof out);

    tot = ;

    cnt = ;

}

void add(int x,int d)

{

    while(x)

    {

        c[x] += d;

        x -= lowbit(x);

    }

}

void add_seg(int l,int r,int d)

{

    add(r,d);

    add(l-,-d);

}

int sum(int x)

{

    int res = ;

    //printf("u:%d ",P[x]);

    while(x <= cnt)

    {

        res += c[x];

        x += lowbit(x);

    }

    //printf("res:%d\n",res);

    return res;

}

int dist(int x)

{

    if(x == -) return ;

    return sum(in[x]) + dis[x];

}

int main()

{

    //freopen("input.txt","r",stdin);

    while(~scanf("%d%d%d",&N,&Q,&S))

    {

        init();

        for(int i=,u,v,w;i<N-;i++)

        {

            scanf("%d%d%d",&u,&v,&w);

            add_edge(u,v,w);

        }

        dfs(,-,,);

        //debug();

        initLCA();

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

        {

            if(dep[e[i].to] < dep[e[i+].to]) swap(e[i].to,e[i+].to);

        }

        int op;

        for(int i=,a,b,c;i<Q;i++)

        {

            scanf("%d",&op);

            if(op == )

            {

                scanf("%d",&a);

                int lca = LCA(S,a);

                //printf("lca:%d\n",lca);

                printf("%d\n",dist(S)+dist(a)-*(dist(lca)));

                S = a;

            }else

            {

                scanf("%d%d",&a,&b);

                a--;

                int u = e[a*].to;

                int dw = b - (dist(u) - dist(fa[u][]));

                //printf("dw:%d u:%d\n",dw,u);

                add_seg(in[u],out[u],dw);

            }

        }

    }

}

#include<cstdio>

#include<algorithm>

#include<cstring>

#define lson l, m, rt << 1

#define rson m + 1, r, rt << 1 | 1

using namespace std;

typedef long long ll;

const int MAXN = 2e5 + ;

int n, q, s;

int fa[MAXN]; // fa[v]: v 的父亲

int dep[MAXN]; // dep[v]: v 的深度（根深度为１）

int siz[MAXN]; // : 以 v 为根的子树的节点数

int son[MAXN]; // : 重儿子，siz[u] 为 v　的子节点中 siz　值最大的，那么 u 就是 v 的重儿子

int top[MAXN]; // : 表示 v 所在的重链的顶端节点

int w[MAXN]; // : 表示 v 与其父亲节点的连边在线段树中的位置

int num; // 将树映射到线段树上的标号

int cnt, head[MAXN];

struct Edge {

    int to, next;

}edge[MAXN];

struct E {

    int u, v, c;

}e[MAXN];

void addedge(int u, int v) {

    edge[cnt].to = v;

    edge[cnt].next = head[u];

    head[u] = cnt++;

}

void dfs(int u) {

    siz[u] = ; son[u] = ;

    for(int i = head[u]; ~i; i = edge[i].next) {

        if(edge[i].to != fa[u]) {

            fa[edge[i].to] = u;

            dep[edge[i].to] = dep[u] + ;

            dfs(edge[i].to);

            if(siz[edge[i].to] > siz[son[u]]) son[u] = edge[i].to;

            siz[u] += siz[edge[i].to];

        }

    }

}

void build_tree(int u, int tp) {

    w[u] = ++num; top[u] = tp;

    if(son[u]) build_tree(son[u], top[u]); // 使重链各边在线段树中呈连续分布

    for(int i = head[u]; ~i; i = edge[i].next) {

        int v = edge[i].to;

        if(v != son[u] && v != fa[u])

            build_tree(v, v);

    }

}

ll sum[MAXN];

void pushUp(int rt) {

    sum[rt] = sum[rt << ] + sum[rt <<  | ];

}

void build(int l, int r, int rt) {

    sum[rt] = ;

    if(l == r) return;

    int m = (l + r) / ;

    build(lson); build(rson);

}

void update(int p, int c, int l, int r, int rt) {

    if(l == r) {

        sum[rt] = c;

        return;

    }

    int m = (l + r) / ;

    if(m >= p) update(p, c, lson);

    else update(p, c, rson);

    pushUp(rt);

}

ll query(int L, int R, int l, int r, int rt) {

    if(L <= l && R >= r) return sum[rt];

    int m = (l + r) / ;

    ll res = ;

    if(m >= L) res += query(L, R, lson);

    if(m < R) res += query(L, R, rson);

    return res;

}

void change(int v, int c) {

    if(dep[e[v].u] > dep[e[v].v]) update(w[e[v].u], c, , n, );

    else update(w[e[v].v], c, , n, );

}

ll seek(int v, int u) {

    int t1 = top[v], t2 = top[u];

    ll res = ;

    while(t1 != t2) {

        if(dep[t1] < dep[t2]) {

            swap(t1, t2); swap(v, u);

        }

        res += query(w[t1], w[v], , n, );

        v = fa[t1]; t1 = top[v];

    }

    if(v == u) return res;

    if(dep[v] > dep[u]) swap(v, u);

    return res + query(w[son[v]], w[u], , n, );

}

int main() {

    memset(head, -, sizeof head);

    cnt = num = ;

    scanf("%d%d%d", &n, &q, &s);

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

        scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].c);

        addedge(e[i].u, e[i].v);

        addedge(e[i].v, e[i].u);

    }

    dfs();

    build_tree(, );

    build(, n, );

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

        if(dep[e[i].u] > dep[e[i].v]) update(w[e[i].u], e[i].c, , n, );

        else update(w[e[i].v], e[i].c, , n, );

    }

    while(q--) {

        int cc;

        int x, y;

        scanf("%d", &cc);

        if(cc) {

            scanf("%d%d", &x, &y);

            change(x, y);

        } else {

            scanf("%d", &x);

            printf("%lld\n", seek(s, x));

            s = x;

        }

    }

    return ;

}