#include<bits/stdc++.h>

using namespace std;

#define MAXN 100010

struct Edge

{

        int to,nxt;

} e[MAXN*];

int i,opt,n,m,q,x,y,val,tot,timer;

int dfn[MAXN],pos[MAXN],head[MAXN],size[MAXN],

        son[MAXN],top[MAXN],fa[MAXN],dep[MAXN];

long long a[MAXN];

template <typename T> inline void read(T &x)

{

    long long f = ; x = ;

    char c = getchar();

    for (; !isdigit(c); c = getchar()) { if (c == '-') f = -f; }

    for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';

    x *= f;

}

template <typename T> inline void write(T x)

{

    if (x < )

    {

        putchar('-');

        x = -x;

    }

    if (x > ) write(x/);

    putchar(x%+'');

}

template <typename T> inline void writeln(T x)

{

    write(x);

    puts("");

}

struct SegmentTree

{

        struct Node

        {

                int l,r;

                long long sum,tag;

        } Tree[MAXN*];

        inline void update(int index)

        {

                Tree[index].sum = Tree[index<<].sum + Tree[index<<|].sum;

        }

        inline void pushdown(int index)

        {

                int l = Tree[index].l,r = Tree[index].r;

                int mid = (l + r) >> ;

                if (Tree[index].tag)

                {

                        Tree[index<<].sum += Tree[index].tag * (mid - l + );

                        Tree[index<<|].sum += Tree[index].tag * (r - mid);

                        Tree[index<<].tag += Tree[index].tag;

                        Tree[index<<|].tag += Tree[index].tag;

                        Tree[index].tag = ;

                }

        }

        inline void build(int index,int l,int r)

        {

                int mid;

                Tree[index].l = l;

                Tree[index].r = r;

                if (l == r)

                {

                        Tree[index].sum = a[pos[l]];

                        return;

                }

                mid = (l + r) >> ;

                build(index<<,l,mid);

                build(index<<|,mid+,r);

                update(index);

        }

        inline void add1(int index,int pos,long long val)

        {

                int mid;

                if (Tree[index].l == Tree[index].r)

                {

                        Tree[index].sum += val;

                        return;

                }

                pushdown(index);

                mid = (Tree[index].l + Tree[index].r) >> ;

                if (mid >= pos) add1(index<<,pos,val);

                else add1(index<<|,pos,val);

                update(index);

        }

        inline void add2(int index,int l,int r,long long val)

        {

                int mid;

                if (Tree[index].l == l && Tree[index].r == r)

                {

                        Tree[index].sum += val * (r - l + );

                        Tree[index].tag += val;

                        return;

                }

                pushdown(index);

                mid = (Tree[index].l + Tree[index].r) >> ;

                if (mid >= r) add2(index<<,l,r,val);

                else if (mid +  <= l) add2(index<<|,l,r,val);

                else

                {

                        add2(index<<,l,mid,val);

                        add2(index<<|,mid+,r,val);

                }

                update(index);

        }

        inline long long query(int index,int l,int r)

        {

                int mid;

                if (Tree[index].l == l && Tree[index].r == r) return Tree[index].sum;

                pushdown(index);

                mid = (Tree[index].l + Tree[index].r) >> ;

                if (mid >= r) return query(index<<,l,r);

                else if (mid +  <= l) return query(index<<|,l,r);

                else return query(index<<,l,mid) + query(index<<|,mid+,r);

        }

} T;

inline void add(int u,int v)

{

        tot++;

        e[tot] = (Edge){v,head[u]};

        head[u] = tot;

}

inline void dfs1(int x)

{

        int i,y;

        size[x] = ;

        for (i = head[x]; i; i = e[i].nxt)

        {

                y = e[i].to;

                if (fa[x] != y)

                {

                        fa[y] = x;

                        dep[y] = dep[x] + ;

                        dfs1(y);

                        size[x] += size[y];

                        if (size[y] > size[son[x]]) son[x] = y;

                }

        }

}

inline void dfs2(int x,int tp)

{

        int i,y;

        top[x] = tp;

        dfn[x] = ++timer;

        pos[timer] = x;

        if (son[x]) dfs2(son[x],tp);

        for (i = head[x]; i; i = e[i].nxt)

        {

                y = e[i].to;

                if (fa[x] != y && son[x] != y) dfs2(y,y);

        }

}

inline long long query(int x)

{

        long long ans = ;

        int tx = top[x];

        while (tx != )

        {

                ans += T.query(,dfn[tx],dfn[x]);

                x = fa[tx]; tx = top[x];

        }

        ans += T.query(,,dfn[x]);

        return ans;

}

int main() {

        read(n); read(q);

        for (i = ; i <= n; i++) read(a[i]);

        for (i = ; i < n; i++)

        {

                read(x); read(y);

                add(x,y);

                add(y,x);

        }

        dfs1();

        dfs2(,);

        T.build(,,timer);

        while (q--)

        {

                read(opt);

                if (opt == )

                {

                        read(x); read(val);

                        T.add1(,dfn[x],val);

                }

                if (opt == )

                {

                        read(x); read(val);

                        T.add2(,dfn[x],dfn[x]+size[x]-,val);

                }

                if (opt == )

                {

                        read(x);

                        writeln(query(x));

                }

        }

        return ;

}