#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 2e5 + 5;
const ll linf = 0x3f3f3f3f3f3f3f3f;

struct Seg
{
	ll l,r;
	Seg(void): l(linf), r(-linf) {}
	Seg(ll _l,ll _r): l(_l), r(_r) {}
	Seg operator + (const Seg &oth) const { return Seg(min(l, oth.l), max(r, oth.r));}
};

struct Segment_Tree
{
	int N;
	vector<int> id;
	vector<Seg> f;
	void init(vector<int> _id)
	{
		id = _id;
		sort(id.begin(), id.end());
		int n = (int)id.size();
		
		N = 1;
		while(N < n+2) N <<= 1;
		f.resize(2 * N);
	}
	void set(int i,ll k)
	{
		i = lower_bound(id.begin(), id.end(), i) - id.begin() + 1;
		i += N;
		if(k == -1) f[i] = Seg();
		else f[i] = Seg(k, k);
		while(i>>=1)
			f[i] = f[i<<1] + f[i<<1|1];
	}
	Seg query(int l,int r)
	{
		l = lower_bound(id.begin(), id.end(), l) - id.begin() + 1;
		r = upper_bound(id.begin(), id.end(), r) - id.begin();
		if(l > r) return Seg();
		
		Seg res;
		for(l+=N-1, r+=N+1; l^r^1; l>>=1, r>>=1)
		{
			if(~l&1) res = res + f[l^1];
			if( r&1) res = res + f[r^1];
		}
		return res;
	}
}ds[105];

vector<pii> g[MAXN];
vector<int> ch[MAXN];
ll dep[MAXN];
int bot[MAXN];

int clr[MAXN], ccnt = 0;

void dfs_tree(int u,int fa)
{
	for(auto it: g[u]) if(it.first != fa)
	{
		int v = it.first, w = it.second;
		ch[u].emplace_back(v);
		dep[v] = dep[u] + w;
		dfs_tree(v,u);
	}
	if((int)ch[u].size() == 1)
		bot[u] = bot[ch[u][0]];
	else
		bot[u] = u;
}

void dfs_ds(int u)
{
	++ccnt;
	vector<int> id;
	while(1)
	{
		clr[u] = ccnt;
		id.emplace_back(u);
		if(bot[u] == u) break;
		u = ch[u][0];
	}
	ds[ccnt].init(id);
	
	for(int v: ch[u])
		dfs_ds(v);
}

struct Data
{
	ll sum, k;
	Data(void){}
	Data(ll _sum,ll _k): sum(_sum), k(_k) {}
};

Data merge(Data A,Data B,int u)
{
	if(A.k == -1) return B;
	if(B.k == -1) return A;
	return Data(A.sum + B.sum + A.k + B.k - dep[u] * 2, dep[u]);
}

Data query(int u,int l,int r)
{
	u = bot[u];
	
	Data res(0, -1);
	for(int v: ch[u])
	{
		auto cur = query(v,l,r);
		res = merge(res, cur, u);
	}
	
	Seg cur = ds[clr[u]].query(l,r);
	if(cur.l > cur.r)
		return res;
	
	if(res.k == -1)
		return Data(cur.r - cur.l, cur.l);
	
	return Data(res.sum + res.k - cur.l, cur.l);
}

char s[MAXN];
int a[MAXN];

int main(void)
{
	int n,Q;
	scanf("%d%d%s",&n,&Q,s+1);
	for(int i=1; i<n; ++i)
	{
		int u,v,w;
		scanf("%d%d%d",&u,&v,&w);
		g[u].emplace_back(v,w);
		g[v].emplace_back(u,w);
	}
	
	dfs_tree(1,0);
	dfs_ds(1);
	
	auto update = [&] (int u)
	{
		if(a[u] == 0)
		{
			a[u] = 1;
			ds[clr[u]].set(u, dep[u]);
		}
		else
		{
			a[u] = 0;
			ds[clr[u]].set(u, -1);
		}
	};
	
	for(int i=1; i<=n; ++i)
		if(s[i] == '1')
			update(i);
	
	while(Q--)
	{
		int type;
		scanf("%d",&type);
		if(type == 1)
		{
			int x;
			scanf("%d",&x);
			update(x);
		}
		else
		{
			int l,r;
			scanf("%d%d",&l,&r);
			auto res = query(1,l,r);
			printf("%lld\n",res.k == -1? -1ll: res.sum * 2);
		}
	}
	return 0;
}