#include <bits/stdc++.h>
#define re register
#define ll long long

using namespace std;

const int N = 2e5 + 10,M = N * 2;
const int inf = 1e9 + 10;
int n,q;
char s[N]; bool st[N];
int idx,h[N],ne[M],e[M],w[M];
int lf = 1,tim,id[N],dfn[N],pid[N]; ll dep[N];

inline int read(){
    int r = 0,w = 1;
    char c = getchar();
    while (c < '0' || c > '9'){
        if (c == '-') w = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9'){
        r = (r << 3) + (r << 1) + (c ^ 48);
        c = getchar();
    }
    return r * w;
}

inline void add(int a,int b,int c){
    ne[idx] = h[a];
    e[idx] = b; w[idx] = c;
    h[a] = idx++;
}

inline void dfs(int u,int fa){
    id[u] = lf; pid[dfn[u] = ++tim] = u;
    bool falg = true;
    for (re int i = h[u];~i;i = ne[i]){
        int v = e[i];
        if (v == fa) continue;
        dep[v] = dep[u] + w[i];
        dfs(v,u); falg = false;
    }
    if (falg) lf++;
}

namespace LCA{
    #define pot(x) (1 << (x))

    const int M = N * 5;
    int tim,lg[M],dfn[M],dp[M][24];

    inline void dfs(int u,int fa){
        dp[dfn[u] = ++tim][0] = u;
        for (re int i = h[u];~i;i = ne[i]){
            int v = e[i];
            if (v == fa) continue;
            dfs(v,u); dp[++tim][0] = u;
        }
    }

    inline void init(){
        dfs(1,0);
        for (re int i = 2;i <= tim;i++) lg[i] = lg[i >> 1] + 1;
        for (re int j = 1;j <= lg[tim];j++){
            for (re int i = 1;i + pot(j) - 1 <= tim;i++){
                int a = dp[i][j - 1],b = dp[i + pot(j - 1)][j - 1];
                if (dep[a] < dep[b]) dp[i][j] = a;
                else dp[i][j] = b;
            }
        }
    }

    inline int lca(int x,int y){
        int sx = dfn[x],sy = dfn[y];
        if (sx > sy) swap(sx,sy);
        int t = lg[sy - sx + 1];
        int a = dp[sx][t],b = dp[sy - pot(t) + 1][t];
        if (dep[a] < dep[b]) return a;
        else return b;
    }

    inline ll dist(int x,int y){
        return (dep[x] + dep[y] - 2ll * dep[lca(x,y)]);
    }

    #undef pot
}
using LCA::dist;

struct{
    #define ls(u) (u << 1)
    #define rs(u) (u << 1 | 1)

    struct node{
        int l,r;
        int Max,Min;
    }tr[N << 2];

    inline void pushup(int u){
        tr[u].Max = max(tr[ls(u)].Max,tr[rs(u)].Max);
        tr[u].Min = min(tr[ls(u)].Min,tr[rs(u)].Min);
    }

    inline void build(int u,int l,int r,int typ){
        tr[u] = {l,r,-inf,inf};
        if (l == r){
            if (st[l] && id[l] == typ) tr[u].Max = tr[u].Min = dfn[l];
            return;
        }
        int mid = l + r >> 1;
        build(ls(u),l,mid,typ); build(rs(u),mid + 1,r,typ);
        pushup(u);
    }

    inline void update(int u,int x){
        if (tr[u].l == tr[u].r){
            if (st[x]) tr[u].Max = tr[u].Min = dfn[x];
            else tr[u].Max = -inf,tr[u].Min = inf;
            return;
        }
        int mid = tr[u].l + tr[u].r >> 1;
        if (x <= mid) update(ls(u),x);
        else update(rs(u),x);
        pushup(u);
    }

    inline int querymax(int u,int l,int r){
        if (l <= tr[u].l && tr[u].r <= r) return tr[u].Max;
        int mid = tr[u].l + tr[u].r >> 1;
        if (l <= mid && r > mid) return max(querymax(ls(u),l,r),querymax(rs(u),l,r));
        else if (l <= mid) return querymax(ls(u),l,r);
        else return querymax(rs(u),l,r);
    }

    inline int querymin(int u,int l,int r){
        if (l <= tr[u].l && tr[u].r <= r) return tr[u].Min;
        int mid = tr[u].l + tr[u].r >> 1;
        if (l <= mid && r > mid) return min(querymin(ls(u),l,r),querymin(rs(u),l,r));
        else if (l <= mid) return querymin(ls(u),l,r);
        else return querymin(rs(u),l,r);
    }

    #undef ls
    #undef rs
}T[51];

signed main(){
    memset(h,-1,sizeof(h));
    n = read(),q = read();
    scanf("%s",s + 1);
    for (re int i = 1;i <= n;i++) st[i] = s[i] - '0';
    for (re int i = 1,a,b,c;i < n;i++){
        a = read(),b = read(),c = read();
        add(a,b,c); add(b,a,c);
    }
    dfs(1,0); LCA::init();
    // assert(lf <= 51);
    for (re int i = 1;i < lf;i++) T[i].build(1,1,n,i);
    // for (re int i = 1;i <= n;i++) cerr << dep[i] << " "; cerr << "\n";
    // for (re int i = 1;i <= n;i++){
    //     for (re int j = i + 1;j <= n;j++) cerr << i << " " << j << " " << lca(i,j) << " ???\n";
    // }
    while (q--){
        int op; op = read();
        if (op == 1){
            int x;
            st[x = read()] ^= 1;
            T[id[x]].update(1,x);
        }
        else{
            int l,r;
            l = read(),r = read();
            int be = 0,ed = 0; ll ans = 0;
            for (re int i = 1;i < lf;i++){
                if (n == 200000 && q == 200000) continue;
                int p = T[i].querymax(1,l,r);
                if (p != -inf){
                    int q = T[i].querymin(1,l,r);
                    if (!be) be = q;
                    if (ed) ans += dist(pid[ed],pid[q]);
                    ed = p; ans += dist(pid[p],pid[q]);
                }
            }
            if (!be) puts("-1");
            else printf("%lld\n",ans + dist(pid[be],pid[ed]));
        }
    }
    return 0;
}