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

#define int long long
typedef vector<int>vint;
typedef pair<int,int>pint;
typedef vector<pint>vpint;
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,f,n) for(int i=(f);i<(n);i++)
#define all(v) (v).begin(),(v).end()
#define each(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define pb push_back
#define fi first
#define se second
template<typename A,typename B>inline void chmin(A &a,B b){if(a>b)a=b;}
template<typename A,typename B>inline void chmax(A &a,B b){if(a<b)a=b;}

const int INF=1001001001001001001ll;
struct node{
    int v,l,r,s;
    node(int a){
        v=l=r=s=a;
    }
    node(int v,int l,int r,int s):v(v),l(l),r(r),s(s){}
    node(){
        v=l=r=-INF;
        s=0;
    }
};
node operator+(const node &a,const node &b){
    node c;
    c.v=max(max(a.v,b.v),a.r+b.l);
    c.s=a.s+b.s;
    c.l=max(a.l,a.s+b.l);
    c.r=max(b.r,b.s+a.r);
    return c;
}


struct LinkCutTree{;
    struct Node{
        Node *lp,*rp,*pp;
        int cnt;
        bool rev;
        int val,put;
        node agg;
        Node():lp(0),rp(0),pp(0),rev(0),cnt(1),put(INF){}
        bool isRoot(){
            return !pp||(pp->lp!=this&&pp->rp!=this);
        }

        void push(){
            if(rev){
                swap(lp,rp);
                swap(agg.l,agg.r);
                if(lp)lp->rev^=1;
                if(rp)rp->rev^=1;
            }
            if(put!=INF){
                val=put;
                if(put>=0)agg=node(put*cnt);
                else agg=node(put,put,put,put*cnt);
                if(lp)lp->put=put;
                if(rp)rp->put=put;
            }

            rev=false;
            put=INF;
        }

        void push_all(){
            if(!isRoot())pp->push_all();
            push();
            if(lp)lp->push();
            if(rp)rp->push();
        }

        void update(){
            cnt=(lp?lp->cnt:0)+1+(rp?rp->cnt:0);
            agg=node(val);
            if(lp)agg=lp->agg+agg;
            if(rp)agg=agg+rp->agg;
        }

        void rotR(){
            Node *q=pp,*r=q->pp;
            if((q->lp=rp))rp->pp=q;
            rp=q;q->pp=this;
            if((pp=r)){
                if(r->lp==q)r->lp=this;
                if(r->rp==q)r->rp=this;
            }
            q->update();
            update();
        }

        void rotL(){
            Node *q=pp,*r=q->pp;
            if((q->rp=lp))lp->pp=q;
            lp=q;q->pp=this;
            if((pp=r)){
                if(r->lp==q)r->lp=this;
                if(r->rp==q)r->rp=this;
            }
            q->update();
            update();
        }


        void splay(){
            push_all();
            while(!isRoot()){
                Node *q=pp;
                if(q->isRoot()){
                    if(q->lp==this)rotR();
                    else rotL();
                }
                else{
                    Node *r=q->pp;
                    if(r->lp==q){
                        if(q->lp==this){q->rotR();rotR();}
                        else {rotL();rotR();}
                    }
                    else{
                        if(q->rp==this){q->rotL();rotL();}
                        else{rotR();rotL();}
                    }
                }
            }
        }

        void expose(){
            Node *rp=NULL;
            for(Node *p=this;p;p=p->pp){
                p->splay();
                p->rp=rp;
                rp=p;
                p->update();
            }
            splay();
        }
    };

    Node *nodes;
    LinkCutTree(int n){nodes=new Node[n];}

    //???(v->v??????)?????????
    void cut(int v){
        nodes[v].expose();
        Node *p=nodes[v].lp;
        nodes[v].lp=NULL;
        p->pp=NULL;
        nodes[v].update();
    }

    //???(v->u)?????????
    void link(int v,int u){
        nodes[v].expose();
        nodes[u].expose();
        nodes[v].pp=&nodes[u];
        nodes[u].rp=&nodes[v];
        nodes[u].update();
    }

    void addEdge(int v,int u){
        evert(v);
        link(v,u);
    }

    int lca(int a,int b){
        nodes[a].expose();
        nodes[b].expose();

        bool sameTree=false;
        Node *ret=&nodes[a];
        for(Node *x=&nodes[a];x;x=x->pp){
            if(x->pp&&x->isRoot())ret=x->pp;
            if(x==&nodes[b])sameTree=true;
        }
        return sameTree?(ret-nodes):-1;
    }

    void evert(int v){
        nodes[v].expose();
        nodes[v].rev^=1;
    }

    int findRoot(int v){
        Node *p=&nodes[v];
        p->expose();
        while(p->lp)p=p->lp;
        p->splay();
        return p-nodes;
    }

    void update(int v,int u,int c){
        evert(u);
        nodes[v].expose();
        nodes[v].put=c;
    }

    int query(int v,int u){
        evert(u);
        nodes[v].expose();
        return nodes[v].agg.v;
    }
};

int N,Q;
int W[222222];
void solve(){

    scanf("%lld%lld",&N,&Q);
    rep(i,N)scanf("%lld",&W[i]);

    LinkCutTree lct(N);
    rep(i,N)lct.nodes[i].val=W[i],lct.nodes[i].agg=node(W[i]);
    rep(i,N-1){
        int a,b;
        scanf("%lld%lld",&a,&b);
        a--;b--;
        lct.addEdge(a,b);
    }

    while(Q--){
        int t,a,b,c;
        scanf("%lld%lld%lld%lld",&t,&a,&b,&c);
        a--;b--;
        if(t==1){
            lct.update(a,b,c);
        }
        else{
            printf("%lld\n",lct.query(a,b));
        }
    }
}

long long esp_org, esp_new;
signed main(){
    const int size = 128*1024*1024;
    void *p = malloc(size);
    esp_new = (long long)p + size - 1;
    __asm__("mov %%rsp, %0" : "=r"(esp_org) : : );
    __asm__("mov %0, %%rsp" : : "r"(esp_new) : );
    solve();
    __asm__("mov %0, %%rsp" : : "r"(esp_org) : );
    free(p);
    return 0;
}

Measured memory_bytes: 21964