#include <bits/stdc++.h>

using namespace std;

#define int long long
#define mp make_pair
#define pb emplace_back
#define rep(i, s, e) for (int i = s; i <= e; ++i)
#define drep(i, s, e) for (int i = s; i >= e; --i)
#define file(a) freopen(#a".in", "r", stdin), freopen(#a".out", "w", stdout)
#define pv(a) cout << #a << " = " << a << endl
#define pa(a, l, r) cout << #a " : "; rep(_, l, r) cout << a[_] << ' '; cout << endl

using pii = pair <int, int>;

const int N = 2e5 + 10;
const int M = 20;

int read() {
  int x = 0, f = 1; char c = getchar();
  for (; c < '0' || c > '9'; c = getchar()) if (c == '-') f = -1;
  for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - 48;
  return x * f;
}

int n, q;
char str[N];
vector <pii> e[N];

int p[N], d0[N], dep[N], dfn[N], dn, id[N], col[N], cn, st[N][M];

void dfs0(int u, int fa) {
  // cout << "u, fa = " << u << ' ' << fa << endl;
  p[u] = fa, dfn[u] = ++ dn, id[dfn[u]] = u;
  bool flag = false;
  for (auto [v, w] : e[u]) if (v != fa) {
    d0[v] = d0[u] + 1, dep[v] = dep[u] + w;
    if (!flag) col[v] = col[u], flag = true;
    else col[v] = ++ cn;
    dfs0(v, u);
  }
}

int Max(int u, int v) {
  if (!u || !v) return u | v;
  return d0[u] > d0[v] ? u : v;
}

int Min(int u, int v) {
  if (!u || !v) return u | v;
  return d0[u] < d0[v] ? u : v;
}

void init() {
  rep(i, 1, n) st[dfn[i]][0] = i;
  rep(j, 1, 19) rep(i, 1, n - (1 << j) + 1) {
    st[i][j] = Min(st[i][j - 1], st[i + (1 << j - 1)][j - 1]);
  }
}

int LCA(int u, int v) {
  if (u == v) return u;
  u = dfn[u], v = dfn[v];
  if (u > v) swap(u, v);
  int t = __lg(v - u);
  return p[Min(st[u + 1][t], st[v - (1 << t) + 1][t])];
}

int dist(int u, int v) {
  if (!u || !v) return 0;
  int lca = LCA(u, v);
  return dep[u] + dep[v] - 2 * dep[lca];
}

// struct node {
//   int u, v;
//   node() {}
//   node(int x, int y) : u(x), v(y) {}
//   friend node operator + (node a, node b) {
//     int mx = -1;
//     for (auto x : {a.u, a.v, b.u, b.v}) {
//       for (int y : {a.u, a.v, b.u, b.v}) {
//         mx = max(mx, dist(x, y));
//       }
//     }
//     for (auto x : {a.u, a.v, b.u, b.v}) {
//       for (int y : {a.u, a.v, b.u, b.v}) {
//         if (dist(x, y) == mx) return node(x, y);
//       }
//     }
//   }
// } ;

#define ls lson[u]
#define rs rson[u]
#define mid (l + r >> 1)

int tot, rt[N], lson[N * M], rson[N * M];

struct node {
  int mx, mn;
  node() : mx(), mn() {}
  node(int u, int v) : mx(u), mn(v) {}
  friend node operator + (node a, node b) {
    return node(Max(a.mx, b.mx), Min(a.mn, b.mn));
  }
} dat[N * M];

void maintain(int u) {
  dat[u] = dat[ls] + dat[rs];
}

int modify(int p, int k, int u, int l, int r) {
  // cout << "p, k, u, l, r = " << p << ' ' << k << ' ' << u << ' ' << l << ' ' << r << endl;
  if (!u) u = ++ tot;
  if (l == r) {
    dat[u] = node(k, k);
    return u;
  }
  if (p <= mid) ls = modify(p, k, ls, l, mid);
  else rs = modify(p, k, rs, mid + 1, r);
  maintain(u);
  // cout << "p, k = " << p << ' ' << k << endl;
  // cout << "u, l, r, mx, mn = " << u << ' ' << l << ' ' << r << ' ' << dat[u].mx << ' ' << dat[u].mn << endl;
  return u;
}

node query(int ql, int qr, int u, int l, int r) {
  // cout << "ql, qr, u, l, r = " << ql << ' ' << qr << ' ' << u << ' ' << l << ' ' << r << endl;
  if (!u) return node();
  if (ql <= l && r <= qr) return dat[u];
  node res = node();
  if (ql <= mid) res = res + query(ql, qr, ls, l, mid);
  if (qr > mid) res = res + query(ql, qr, rs, mid + 1, r);
  return res;
}

#undef ls
#undef rs
#undef mid

signed main() {
  n = read(), q = read(), scanf("%s", str + 1);
  rep(i, 1, n - 1) {
    int u = read(), v = read(), w = read();
    e[u].pb(mp(v, w)), e[v].pb(mp(u, w));
  }
  col[1] = cn = 1, dfs0(1, 0), init();
  // pa(col, 1, n);
  // pa(dfn, 1, n);
  // rep(i, 1, n) rep(j, 1, n) {
    // cout << "i, j, LCA = " << i << ' ' << j << ' ' << LCA(i, j) << endl;
  // }
  rep(i, 1, n) if (str[i] == '1') {
    rt[col[i]] = modify(i, i, rt[col[i]], 1, n);
  }
  while (q --) {
    int op = read();
    if (op == 1) {
      int p = read();
      if (str[p] == '1') {
        rt[col[p]] = modify(p, 0, rt[col[p]], 1, n);
      }
      else {
        rt[col[p]] = modify(p, p, rt[col[p]], 1, n);
      }
      str[p] = '0' ^ '1' ^ str[p];
    }
    else {
      int l = read(), r = read(), fst = 0, lst = 0, ans = 0;
      rep(i, 1, cn) {
        node res = query(l, r, rt[i], 1, n);
        // cout << "i, mx, mn = " << i << ' ' << res.mx << ' ' << res.mn << endl;
        if (!res.mx) continue;
        if (!fst) fst = res.mn;
        ans += dist(lst, res.mn);
        ans += dep[res.mx] - dep[res.mn];
        lst = res.mx;
      }
      ans += dist(fst, lst);
      printf("%lld\n", lst ? ans : -1ll);
    }
  }
  return 0;
}