#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <sstream>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <string>
#include <queue>
#include <bitset>		//UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <iomanip>		//do setprecision
#include <ctime>
#include <complex>
using namespace std;

#define FOR(i,b,e) for(int i=(b);i<(e);++i)
#define FORQ(i,b,e) for(int i=(b);i<=(e);++i)
#define FORD(i,b,e) for(int i=(b)-1;i>=(e);--i)
#define REP(x, n) for(int x = 0; x < (n); ++x)

#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double

typedef pair<int, int> PII;

const double pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;

const int MR = 1e5 + 10;
const int MS = 20;
const LL inf = 2e18;

// wskazniki na korzenie poszczegolnych drzew
pair<LL, int> *tree[MR];
LL *d[MR];

int h[MR];

// modified version of: http://codeforces.com/blog/entry/18051
void apply(int p, LL value, pair<LL,int> *t, LL *d, int n) {
	t[p].first += value;
	if (p < n) d[p] += value;
}

void build(int p, pair<LL, int> *t, LL *d) {
	while (p > 1) p >>= 1, t[p] = max(t[p << 1], t[p << 1 | 1]), t[p].first += d[p];
}

void push(int p, pair<LL, int> *t, LL *d, int h, int n) {
	for (int s = h; s > 0; --s) {
		int i = p >> s;
		if (d[i] != 0) {
			apply(i << 1, d[i], t, d, n);
			apply(i << 1 | 1, d[i], t, d, n);
			d[i] = 0;
		}
	}
}

void inc(int l, int r, LL value, pair<LL, int> *t, LL * d, int n) {
	l += n, r += n;
	int l0 = l, r0 = r;
	for (; l < r; l >>= 1, r >>= 1) {
		if (l & 1) apply(l++, value, t, d, n);
		if (r & 1) apply(--r, value, t, d, n);
	}
	build(l0, t, d);
	build(r0 - 1, t, d);
}

pair<LL, int> query(int l, int r, pair<LL, int> *t, LL *d, int h, int n) {
	l += n, r += n;
	push(l, t, d, h, n);
	push(r - 1, t, d, h, n);
	auto res = MP(-inf, 0);
	for (; l < r; l >>= 1, r >>= 1) {
		if (l & 1) res = max(res, t[l++]);
		if (r & 1) res = max(t[--r], res);
	}
	return res;
}

int cntlz(int x)
{
	int last = 0;
	REP(i, 30)
		if (x&(1 << i)) last = i;

	return 31 - last;
}

// ile zyskujemy w wierzcholkach
LL gainV[MR];

// koszt od centroida do wierzch po krawedziach w kazdej fazie
LL cost[MS][MR];

// nr sasiada, koszt krawedzi, pozycja odwrotnej
struct edge
{
	edge(int v, LL cost, int posRev)
	{
		this->v = v;
		this->posRev = posRev;
		this->cost = cost;
	}
	int v, posRev;
	LL cost;
};

vector<edge> g[MR];

int sz[MR], we[MS][MR], wy[MS][MR], czas;

// do prawidlowego dfs-a
int done[MR], cnt;

// ta funkcja w kazdej fazie odpala sie na okrojonym grafie, zeby policzyc nowe rozmiary
void dfs(int nr)
{
	done[nr] = cnt;
	sz[nr] = 1;
	for (const auto &e : g[nr])
		if (done[e.v] != cnt)
		{
			dfs(e.v);
			sz[nr] += sz[e.v];
		}
}

// ta funkcja rusza, po wyznaczeniu nowego centroidu na okrojonym poddrzewie
// i wykonuje wszystkie obliczenia
void go(int nr, LL c, const int& phase, pair<LL, int> *t, int n)
{
	// wyznacz czasy wejscia/wyjscia i zapisz odpowiednie wartosci w drzewie
	// wez nr wierzcholka z minusem, bo szukamy maxa, a chcemy min nr wierzcholka w przypadku remisu
	we[phase][nr] = ++czas;
	t[n+czas-1] = MP(gainV[nr] - c,-nr);

	for (const auto &e : g[nr])
		if (!we[phase][e.v])
			go(e.v, c + e.cost, phase, t, n);

	wy[phase][nr] = ++czas;
	t[n + czas - 1] = MP(gainV[nr] - c, -nr);
}


int prevC[MR], layer[MR], segmentTreeSize[MR];

void CD(int nr, int phase, int prev)
{
	// ten dfs i wyliczanie rozmiarow na nowo jest istotny na poczatku kazdej fazy
	// odpalamy sie na zredukowanym grafie, a rozmiary potrzebne sa do wyznaczenia nowego centroidu
	cnt++;
	dfs(nr);

	// find centroid
	int centroid = nr, par = -1;
	while (true)
	{
		int wsk = -1;
		REP(i, g[centroid].size())
			if (g[centroid][i].v != par && (wsk == -1 || sz[g[centroid][i].v] > sz[g[centroid][wsk].v]))
				wsk = i;
		if (wsk == -1 || sz[g[centroid][wsk].v] <= sz[nr] / 2) break;
		par = centroid;
		centroid = g[centroid][wsk].v;
	}

	// zainicjalizuj tablice dla drzewa w centroidzie
	int n = 2 * sz[nr];
	tree[centroid] = new pair<LL, int>[2 * n + 10];
	d[centroid] = new LL[n + 10];
	REP(i, n)
		d[centroid][i] = 0;

	segmentTreeSize[centroid] = n;

	// odpal sie na centroidzie
	czas = 0;
	go(centroid, 0, phase, tree[centroid], n);

	// buduj drzewo
	h[centroid] = sizeof(int) * 8 - __builtin_clz(n);
	REP(i, n)
		build(n + i, tree[centroid], d[centroid]);

	// add link to previous centroid
	prevC[centroid] = prev;
	layer[centroid] = phase;

	// remove from graph and recurse on children
	REP(i, g[centroid].size())
	{
		int nr = g[centroid][i].v;
		int wsk = g[centroid][i].posRev;
		int nr1 = g[nr].back().v;
		int wsk1 = g[nr].back().posRev;
		g[nr1][wsk1].posRev = wsk;
		swap(g[nr][wsk], g[nr].back());
		g[nr].pop_back();
		CD(nr, phase + 1, centroid);
	}

	g[centroid].clear();
}

bool par(int v, int w, int phase)		//zwraca 1 gdy v jest przodkiem w odp poddrzewie centroidu
{
	return we[phase][v] <= we[phase][w] && wy[phase][v] >= wy[phase][w];
}//par

int main()
{
	int n, q;
	scanf("%d%d", &n, &q);
	REP(i, n)
		scanf("%lld", &gainV[i]);

	map<PII, LL> M;
	REP(i, n - 1)
	{
		int a, b;
		LL c;
		scanf("%d%d%lld", &a, &b, &c); a--; b--;

		M[MP(min(a, b), max(a, b))] = c;

		g[a].push_back(edge(b, c, g[b].size()));
		g[b].push_back(edge(a, c, g[a].size() - 1));
	}

	// przygotuj sobie poczatkowa strukture i zapomnij o grafie
	CD(0, 0, -1);

	int akt = 0;

	REP(i, q)
	{
		int typ;
		scanf("%d", &typ);
		if (typ == 1)
		{
			int v;
			LL nG;
			scanf("%d%lld", &v, &nG); v--;
			LL diff = nG - gainV[v];
			gainV[v] = nG;

			// jedz w gore centroidow
			int p = v;
			while (p != -1)
			{
				// rob update na 2 pozycjach

				// najpierw na wejsciu - pamietaj, ze pozycje zaczynaja sie od 1, a w drzewie sa od 0
				{
					int posWe = we[layer[p]][v] - 1;
					inc(posWe, posWe + 1, diff, tree[p], d[p], segmentTreeSize[p]);
				}
				// potem na wyjsciu
				{
					int posWy = wy[layer[p]][v] - 1;
					inc(posWy, posWy + 1, diff, tree[p], d[p], segmentTreeSize[p]);
				}

				p = prevC[p];
			}
		}
		else
		{
			int a, b;
			LL nC;
			scanf("%d%d%lld", &a, &b, &nC); a--; b--;

			auto tmp = MP(min(a, b), max(a, b));
			// odwrotnie niz przy wierzcholku, koszty krawedzi byly odejmowane
			// czyli roznica to jest stare-nowe
			LL diff = M[tmp] - nC;
			M[tmp] = nC;

			int p = a, q = b;
			while (p != q)
			{
				if (layer[p] > layer[q]) p = prevC[p];
				else if (layer[p] < layer[q]) q = prevC[q];
				else
				{
					p = prevC[p];
					q = prevC[q];
				}
			}

			while (p != -1)
			{
				// sprawdzaj dla kazdego centroidu, ktory z (a,b) jest synem
				if (par(b, a, layer[p]))
					swap(a, b);

				// a jest ojcem i robimy update na poddrzewie b
				int posWe = we[layer[p]][b] - 1;
				int posWy = wy[layer[p]][b] - 1;
				inc(posWe, posWy + 1, diff, tree[p], d[p], segmentTreeSize[p]);

				p = prevC[p];
			}
		}

		// teraz wyszukaj najlepszej sciezki dla wierzcholka akt i go uaktualnij
		int p = akt;

		auto best = MP(-inf, 0);

		// za kazdym razem wyrzuc akt z przedzialu - z rysunku wyglada, ze to wystarczy
		// bo gdyby optimum dla p bylo w poddrzewie akt, to wczesniej bysmy je wykryli i wartosc z centroidu p nie moglaby byc lepsza
		while (p != -1)
		{
			// przedzial wejscia-wyjscia akt podczas przegladu z centroidu p
			int posWe = we[layer[p]][akt] - 1, posWy = wy[layer[p]][akt] - 1;

			// koszt dojscia po krawedziach z akt do p
			auto pom = query(posWe, posWe + 1, tree[p], d[p], h[p], segmentTreeSize[p]);
			// masz gainV - suma krawedzi, chcesz tylko -sumaKrawedzi, wszystkie wartosci sa juz odpowiednio zaktualizowane
			pom.first -= gainV[akt];

			{
				// przed akt
				auto tmp = query(0, posWe, tree[p], d[p], h[p], segmentTreeSize[p]);
				// dodaj koszt dojscia z akt do prev
				tmp.first += pom.first;

				best = max(best, tmp);
			}
			{
				// miedzy wejsciem i wyjsciem akt
				auto tmp = query(posWe + 1, posWy, tree[p], d[p], h[p], segmentTreeSize[p]);
				// dodaj koszt dojscia z akt do prev
				tmp.first += pom.first;

				best = max(best, tmp);
			}
			{
				// za akt
				auto tmp = query(posWy + 1, segmentTreeSize[p], tree[p], d[p], h[p], segmentTreeSize[p]);
				// dodaj koszt dojscia z akt do prev
				tmp.first += pom.first;

				best = max(best, tmp);
			}

			p = prevC[p];
		}

		// pamietaj, ze mamy ujemne nr wierzcholkow, bo drzewo szuka maxa
		akt = -best.second;

		printf("%d ", akt + 1);
	}

	printf("\n");

	return 0;
}