#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define per(i,a,b) for(int i=a;i>b;i--)
#define repLL(i,a,b) for(LL i=(LL)a;i<(LL)b;i++)
#define perLL(i,a,b) for(LL i=(LL)a;i>(LL)b;i--)
#define debug5(a,b,c,d,e) cerr<<#a<<": "<<a<<" "<<#b<<": "<<b<<" "<<#c<<": "<<c<<" "<<#d<<": "<<d<<" "<<#e<<": "<<e<<endl;
#define debug4(a,b,c,d)  cerr<<#a<<": "<<a<<" "<<#b<<": "<<b<<" "<<#c<<": "<<c<<" "<<#d<<": "<<d<<endl;
#define debug3(a,b,c) cerr<<#a<<": "<<a<<" "<<#b<<": "<<b<<" "<<#c<<": "<<c<<endl;
#define debug2(a,b) cerr<<#a<<": "<<a<<" "<<#b<<": "<<b<<endl;
#define debug(a) cerr<<#a<<": "<<a<<endl;
#define pb push_back
#define mp make_pair
#define SZ(x) ((int)(x).size())
#define ALL(x) x.begin(),x.end()
#define fi first
#define se second
#define _upgrade ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
typedef pair<LL,LL> PLL;
typedef vector<PII> VPII;
typedef vector<PLL> VPLL;
typedef vector<LL> VLL;
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<char> VC;
typedef long double LD;
typedef pair<LD,LD> PLD;
typedef vector<LD> VLD;
typedef vector<PLD> VPLD;

const int maxn=(1e5)+7;// liczba wierzchołków
const int logmax=18;
const int inf=(1e9)+7;
const LL LLinf=(2e18)+7;
const LD eps=1e-9;
const LL mod=1e9+7;

// ***************************** CODE ***************************** //

// pamiec do drugiej czesci

int PRE[maxn],POST[maxn];
int father[maxn][logmax];
LL pot=(1<<logmax);
LL drzewko[((1<<(logmax+1)))+7];
int t=0;
LL wartosc[maxn];
vector<pair<int,LL> > wek[maxn];
map<PII,LL> krawedzie;// krawedz ( min , max ) -> jej wartosc

int centrofather[maxn][logmax]; // centrofather[i][j] - ojciec i po puszczeniu dfsa w drzewie na poziomie j
int T[logmax];
int pre[maxn][logmax];
int post[maxn][logmax];
int level[maxn]; // poziom w drzewie centoidow

// pamiec do pierwszej czesci

bool zamkniete[maxn];
int roz[maxn];
VI V;
int ojciec[maxn]; // ojciec w drzewie centroidow

// drzewo przedzial przedzial  - dodaj na przedziale zwraca numer wierzcholka i jego wartosc

LL tree[(1<<logmax)*2+7][logmax]; // trzyma zmiane w punkcie
pair<int,LL> drze[(1<<logmax)*2 + 7 ][logmax]; // trzyma optymalny wynik dla poddrzewa

pair<int,LL> lepszy(pair<int,LL> a, pair<int,LL> b)
{
      if(a.se!=b.se)
      {
            if(a.se>b.se)
                  return a;
            return b;
      }
      if(a.fi<b.fi)
            return a;
      return b;
}

void dodaj(int poziom,int lewo,int prawo,int l,int p,int wierz,LL val)
{
      if(p<lewo || prawo<l)
            return ;
      if(l<=lewo && prawo<=p) // jest przedzialem bazowym
      {
            tree[wierz][poziom]+=val;
            drze[wierz][poziom].se+=val;
            if(drze[wierz][poziom].fi<0)
                  cout<<wierz<<" "<<drze[wierz][poziom].fi<<endl;
            return ;
      }
      int sr=(lewo+prawo)/2;
      dodaj(poziom,lewo,sr,l,p,2*wierz,val);
      dodaj(poziom,sr+1,prawo,l,p,2*wierz+1,val);
      drze[wierz][poziom]=lepszy(drze[2*wierz][poziom],drze[2*wierz+1][poziom]);
      drze[wierz][poziom].se+=tree[wierz][poziom];
      return ;
}

pair<int,LL> najlepszy(int poziom,int lewo,int prawo,int l,int p,int wierz)
{
      if(p<lewo || prawo<l)
            return {0,-LLinf};
      if(l<=lewo && prawo<=p) // jest przedzialem bazowym
            return drze[wierz][poziom];
      int sr=(lewo+prawo)/2;
      pair<int,LL> a=lepszy(najlepszy(poziom,lewo,sr,l,p,2*wierz),najlepszy(poziom,sr+1,prawo,l,p,2*wierz+1));
      a.se+=tree[wierz][poziom];
      // assert(wierz<pot);
      return a;
}

void ustaw(int x,int numer,int poziom)
{
      x+=pot;
      drze[x][poziom].fi=numer;
}
// koniec drzewa przedzial przedzial

void rekure(int x,int f)
{
      V.pb(x);
      roz[x]=1;
      for(auto s:wek[x])
            if(zamkniete[s.fi]==0 && s.fi!=f)
            {
                  rekure(s.fi,x);
                  roz[x]+=roz[s.fi];
            }

}

int centroid(int x)
{
      V.clear();
      rekure(x,-1);
      int calosc=roz[x];
      for(auto s:V)
      {
            bool zmienna=0;
            for(auto v:wek[s])
                  if(zamkniete[v.fi]==0 && roz[v.fi]<roz[s])
                        if(roz[v.fi]>calosc/2)
                              zmienna=1;
            if(calosc-roz[s]>calosc/2)
                  zmienna=1;
            if(zmienna)
                  continue;
            return s;
      }
      assert(0); // przemyslec tego asserta xd
}

void dfs(int x,int poziom)
{
      // cout<<x<<" "<<poziom<<endl;
      pre[x][poziom]=++T[poziom];
      ustaw(pre[x][poziom],x,poziom);
      dodaj(poziom,0,pot-1,pre[x][poziom],pre[x][poziom],1,wartosc[x]);
      for(auto s:wek[x])
      {
            // cout<<x<<" "<<s.fi<<" "<<zamkniete[s.fi]<<" "<<father[x][poziom]<<endl;
            if(zamkniete[s.fi]==0 && s.fi!=centrofather[x][poziom])
            {
                  centrofather[s.fi][poziom]=x;
                  dfs(s.fi,poziom);
                  dodaj(poziom,0,pot-1,pre[s.fi][poziom],post[s.fi][poziom],1,-s.se);
            }
      }
      post[x][poziom]=T[poziom];
}

void rozbij(int x,int ojcie,int poziom)
{
      x=centroid(x);
      ojciec[x]=ojcie;
      level[x]=poziom;
      dfs(x,poziom);
      zamkniete[x]=1;
      for(auto s:wek[x])
            if(zamkniete[s.fi]==0)
                  rozbij(s.fi,x,poziom+1);
}

// *********************************** DRUGA CZESC *********************************** //

void pierdodaj(int l,int p,LL val)
{
      l+=pot;
      p+=pot;
      while(l<=p)
      {
            if(l&1)
                  drzewko[l]+=val;
            if((p&1)^1)
                  drzewko[p]+=val;
            p=(p-1)>>1;
            l=(l+1)>>1;
      }
}

LL pierval(int x) // wartosc wierzcholka o numerze x
{
      x=PRE[x];
      x+=pot;
      LL res=0LL;
      while(x>0)
      {
            res+=drzewko[x];
            x>>=1;
      }
      return res;
}

void pier(int x)
{
      PRE[x]=++t;
      for(auto s:wek[x])
      {
            if(father[x][0]!=s.fi)
            {
                  father[s.fi][0]=x;
                  pier(s.fi);
                  pierdodaj(PRE[s.fi],POST[s.fi],-s.se);
            }
      }
      POST[x]=t;
}

bool pierczy(int a,int b)
{
      if(PRE[a]<=PRE[b] && POST[b]<=POST[a])
            return 1;
      return 0;
}

int lca(int a,int b)
{
      int k=logmax-1;
      while(k>-1)
      {
            if(!pierczy(father[b][k],a))
                  b=father[b][k];
            k--;
      }
      if(!pierczy(b,a))
            b=father[b][0];
      return b;
}

LL odleglosc(int a,int b)// zwraca przychod z podrozy z a do b i spania w b
{
      return pierval(a)+pierval(b)-2LL*pierval(lca(a,b));
}

void pierzmienwierz(int x,LL val)// ustaw wartosc w x na val
{
      wartosc[x]=val;
}

void pierzmienkraw(int a,int b,LL val)// ustaw wartosc krawedzi od a do b na val
{
      if(a>b)
            swap(a,b);
      LL curr=krawedzie[{a,b}];
      // cout<<curr<<endl;
      krawedzie[{a,b}]=val;
      if(father[a][0]==b) // a ma byc ojcem
            swap(a,b);
      // cout<<b<<endl;
      // cout<<PRE[b]<<" "<<POST[b]<<endl;
      pierdodaj(PRE[b],POST[b],-val+curr);
}

// ******************************************************************** //

// czesc z centroidu

pair<int,LL> wynikcentroid(int x,int pomin) // najlepszy wynik w drzwie w kotrym x jest centroidem z pominieciem pomin
{
      int poziom=level[x];
      // if(poziom==0)
      // {
      //       cout<<"pocz "<<x<<" ";
      //       rep(i,pre[x][poziom],post[x][poziom]+1)
      //             cout<<drze[i+pot][poziom].se<<" ";
      //       cout<<endl<<endl;
      //       // rep(i,pre[pomin][poziom]+1,post[x][poziom]+1)
      //       //       cout<<drze[i+pot][poziom].fi<<" ";
      //       // cout<<endl;
      // }

      pair<int,LL> a = najlepszy(poziom,0,pot-1,pre[x][poziom],pre[pomin][poziom]-1,1);
      a=lepszy(a,najlepszy(poziom,0,pot-1,pre[pomin][poziom]+1,post[x][poziom],1));
      return a;
}

int wynikkon(int x) // wynik koncowy gdy na poczatku jestesmy w x
{
      int centro=x;
      pair<int,LL> curr={0,-LLinf};
      while(centro != 0)
      {
            // cout<<centro<<endl;
            // cout<<"DDD";
            pair<int,LL> cnt = wynikcentroid(centro,x);
            // cout<<centro<<endl;
            // cout<<"E";
            // cout<<cnt.fi<<" "<<cnt.se<<endl;
            cnt.se=odleglosc(x,cnt.fi)+wartosc[cnt.fi];
            // cout<<centro<<endl;
            if(cnt.fi!=0)
                  curr=lepszy(curr,cnt);
            // cout<<centro<<endl;
            centro = ojciec[centro];
            // cout<<centro<<endl;
      }
      // cout<<curr.fi<<" "<<curr.se<<endl<<endl;
      return curr.fi;
}

void zmienwierz(int x,LL val) // zmienia wartsc w wierzcholku
{
      LL ile=val-wartosc[x];
      rep(i,0,level[x]+1)
            dodaj(i,0,pot-1,pre[x][i],pre[x][i],1,ile);
}

void zmienkraw(int a,int b,LL val) // zmienia wartosc na krawedzi od a do b na val ( nie zmienia wartosci w mapie )
{
      LL ile=-val+krawedzie[{min(a,b),max(a,b)}];
      rep(i,0,min(level[a],level[b])+1)
      {
            if(centrofather[a][i]==b)
            {
                  dodaj(i,0,pot-1,pre[a][i],post[a][i],1,ile);
                  // cout<<"E "<<pre[a][i]<<" "<<post[a][i]<<" "<<ile<<endl;
            }
            else
            {
                  dodaj(i,0,pot-1,pre[b][i],post[b][i],1,ile);
                  // cout<<"E "<<pre[b][i]<<" "<<post[b][i]<<" "<<ile<<endl;
            }
      }
}

int main()
{
      _upgrade
      int n,q;
      cin>>n>>q;
      rep(i,1,n+1)
            cin>>wartosc[i];
      rep(i,1,n)
      {
            int a,b;
            LL v;
            cin>>a>>b>>v;
            wek[a].pb({b,v});
            wek[b].pb({a,v});
            krawedzie[{min(a,b),max(a,b)}]=v;
      }
      pier(1);
      father[1][0]=1;
      rep(k,1,logmax)
            rep(i,1,n+1)
                  father[i][k]=father[father[i][k-1]][k-1];
      rozbij(1,0,0);
      int curr=1;
      // rep(i,1,n+1)
      //       rep(j,i,n+1)
      //             debug4(i,j,odleglosc(i,j),odleglosc(j,i));
      while(q--)
      {
            int a;
            cin>>a;
            // cout<<q<<" "<<a<<endl;
            if(a==1)
            {
                  int b;
                  LL val;
                  cin>>b>>val;
                  zmienwierz(b,val);
                  pierzmienwierz(b,val); // uwaga to juz aktualizuje wartosc w mapie
            }
            else
            {
                  int b,c;
                  LL val;
                  cin>>b>>c>>val;
                  zmienkraw(b,c,val);
                  // cout<<a<<endl;
                  // cout<<b<<" "<<c<<" "<<val<<endl;
                  pierzmienkraw(b,c,val); // uwaga to juz aktualizuje wartosc w mapie
            }
            // cout<<q<<endl;
            curr=wynikkon(curr);
            cout<<curr<<" ";

      }
      // rep(i,1,n+1)
      //       rep(j,i,n+1)
      //             debug4(i,j,odleglosc(i,j),odleglosc(j,i));
      return 0;
}