#include <bits/stdc++.h>
using namespace std;

void just_do_it();

int main() {
	#ifdef KAMIRULEZ
		freopen("kamirulez.inp", "r", stdin);
		freopen("kamirulez.out", "w", stdout);
	#endif
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	just_do_it();
	return 0;
}

const int inf = 1e9 + 20;
const int maxn = 2e5 + 20;
const int maxk = 20;
int a[maxn];
int tin[maxn];
int tout[maxn];
int order[maxn * 2];
int depth_dfs[maxn];
long long depth_w[maxn];
vector<pair<int, int>> adj[maxn];
pair<int, int> sparse[maxn * 2][maxk];
int lg[maxn * 2];
vector<int> leaves;
int dfs_t;

bool is_anc(int u, int v) {
	return tin[u] <= tin[v] && tout[v] <= tout[u];
}

struct seg_tree {
	int leaf;

	pair<int, int> tree[maxn * 4];

	pair<int, int> merge(pair<int, int> p1, pair<int, int> p2) {
		return {max(p1.first, p2.first), min(p1.second, p2.second)};
	}

	void build(int id, int lt, int rt) {
		if (lt == rt) {
			if (a[lt] && is_anc(lt, leaf)) {
				tree[id] = {tin[lt], tin[lt]};
			}
			else {
				tree[id] = {-inf, inf};
			}
			return;
		}
		int mt = (lt + rt) / 2;
		build(id * 2, lt, mt);
		build(id * 2 + 1, mt + 1, rt);
		tree[id] = merge(tree[id * 2], tree[id * 2 + 1]);
	}

	void update(int id, int lt, int rt, int pos) {
		if (lt == rt) {
			if (a[pos]) {
				tree[id] = {tin[pos], tin[pos]};
			}
			else {
				tree[id] = {-inf, inf};
			}
			return;
		}
		int mt = (lt + rt) / 2;
		if (pos <= mt) {
			update(id * 2, lt, mt, pos);
		}
		else {
			update(id * 2 + 1, mt + 1, rt, pos);
		}
		tree[id] = merge(tree[id * 2], tree[id * 2 + 1]);
	}

	pair<int, int> get(int id, int lt, int rt, int ql, int qr) {
		if (lt == ql && rt == qr) {
			return tree[id];
		}
		int mt = (lt + rt) / 2;
		if (qr <= mt) {
			return get(id * 2, lt, mt, ql, qr);
		}
		else if (ql >= mt + 1) {
			return get(id * 2 + 1, mt + 1, rt, ql, qr);
		}
		else {
			return merge(get(id * 2, lt, mt, ql, mt), get(id * 2 + 1, mt + 1, rt, mt + 1, qr));
		}
	}

	seg_tree (int _leaf): leaf(_leaf) {}
};

vector<seg_tree> trees;

void dfs(int u, int p) {
	dfs_t++;
	tin[u] = dfs_t;
	order[dfs_t] = u;
	bool is_leaf = true;
	for (auto e: adj[u]) {
		int v = e.first;
		int w = e.second;
		if (v != p) {
			is_leaf = false;
			depth_dfs[v] = depth_dfs[u] + 1;
			depth_w[v] = depth_w[u] + w;
			dfs(v, u);
			dfs_t++;
			tout[u] = dfs_t;
			order[dfs_t] = u;
		}
	}
	if (is_leaf) {
		trees.emplace_back(u);
	}
}

long long dist(int u, int v) {
	int lt = tin[u];
	int rt = tin[v];
	if (lt > rt) {
		swap(lt, rt);
	}
	int k = lg[rt - lt + 1];
	int lca = min(sparse[lt][k], sparse[rt - (1 << k) + 1][k]).second;
	return depth_w[u] + depth_w[v] - depth_w[lca] * 2;
}

void just_do_it() {
	for (int i = 2; i < maxn * 2; i++) {
		lg[i] = lg[i / 2] + 1;
	}
	int n, q;
	cin >> n >> q;
	for (int i = 1; i <= n; i++) {
		char c;
		cin >> c;
		a[i] = c - '0';
	}
	for (int i = 0; i < n - 1; i++) {
		int u, v, w;
		cin >> u >> v >> w;
		adj[u].emplace_back(v, w);
		adj[v].emplace_back(u, w);
	}
	dfs(1, -1);
	for (int i = 1; i <= n * 2 - 1; i++) {
		sparse[i][0] = {depth_dfs[order[i]], order[i]};
	}
	for (int k = 1; k < maxk; k++) {
		for (int i = 1; i + (1 << k) <= n * 2; i++) {
			sparse[i][k] = min(sparse[i][k - 1], sparse[i + (1 << (k - 1))][k - 1]);
		}
	}
	for (auto &tree: trees) {
		tree.build(1, 1, n);
	}
	for (int i = 0; i < q; i++) {
		int type;
		cin >> type;
		if (type == 1) {
			int u;
			cin >> u;
			a[u] ^= 1;
			for (auto &tree: trees) {
				if (is_anc(u, tree.leaf)) {
					tree.update(1, 1, n, u);
				}
			}
		}
		else {
			int ql, qr;
			cin >> ql >> qr;
			vector<int> leaves;
			int root = inf;
			for (auto &tree: trees) {
				auto p = tree.get(1, 1, n, ql, qr);
				root = min(root, p.second);
				if (p.first != -inf) {
					leaves.push_back(p.first);
				}
			}
			if (root == inf) {
				cout << -1 << '\n';
				continue;
			}
			root = order[root];
			sort(leaves.begin(), leaves.end());
			for (auto &leaf: leaves) {
				leaf = order[leaf];
			}
			long long res = dist(root, leaves[0]);
			for (int i = 0; i < (int)leaves.size() - 1; i++) {
				res += dist(leaves[i], leaves[i + 1]);
			}
			res += dist(leaves.back(), root);
			cout << res << '\n';
		}
	}
}