#ifdef MAIN 
bool __multi__ = 0;

namespace XK {

template <typename T>
struct dual_segment_tree{
  int N;
  vector<T> ST;
  function<T(T, T)> f;
  T E;
  dual_segment_tree(int n, function<T(T, T)> f, T E): f(f), E(E){
    N = 1;
    while (N < n){
      N *= 2;
    }
    ST = vector<T>(N * 2 - 1, E);
  }
  void push(int i){
    if (i < N - 1){
      ST[i * 2 + 1] = f(ST[i * 2 + 1], ST[i]);
      ST[i * 2 + 2] = f(ST[i * 2 + 2], ST[i]);
      ST[i] = E;
    }
  }
  T operator [](int k){
    int v = 0;
    for (int i = N / 2; i >= 1; i >>= 1){
      push(v);
      if ((k & i) == 0){
        v = v * 2 + 1;
      } else {
        v = v * 2 + 2;
      }
    }
    return ST[v];
  }
  void range_apply(int L, int R, T x, int i, int l, int r){
    if (r <= L || R <= l){
    } else if (L <= l && r <= R){
      ST[i] = f(ST[i], x);
    } else {
      push(i);
      int m = (l + r) / 2;
      range_apply(L, R, x, i * 2 + 1, l, m);
      range_apply(L, R, x, i * 2 + 2, m, r);
    }
  }
  void range_apply(int L, int R, T x){
    range_apply(L, R, x, 0, 0, N);
  }
};
const ll mod = 998244353;
struct mm {
   ll x;
   mm(ll x_ = 0) : x(x_ % mod) {
      if(x < 0) x += mod;
   }
   friend mm operator+(mm a, mm b) { return a.x + b.x; }
   friend mm operator-(mm a, mm b) { return a.x - b.x; }
   friend mm operator*(mm a, mm b) { return a.x * b.x; }
   friend mm operator/(mm a, mm b) { return a * b.inv(); }
   friend mm& operator+=(mm& a, mm b) { return a = a.x + b.x; }
   friend mm& operator-=(mm& a, mm b) { return a = a.x - b.x; }
   friend mm& operator*=(mm& a, mm b) { return a = a.x * b.x; }
   friend mm& operator/=(mm& a, mm b) { return a = a * b.inv(); }
   mm inv() const { return pow(mod - 2); }
   mm pow(ll b) const {
      mm a = *this, c = 1;
      while(b) {
         if(b & 1) c *= a;
         a *= a;
         b >>= 1;
      }
      return c;
   }
};

using pmm = pair<mm, mm>;

pmm comp(pmm a, pmm b) {
	return {
		a.fst * b.fst,
		a.snd * b.fst + b.snd
	};
}

  void solve() {
  	int N, Q; cin >> N >> Q;
  	V<V<int>> e(N);
  	rep(i, N - 1) {
  		int u, v; cin >> u >> v; -- u, -- v;
  		e[u].pb(v), e[v].pb(u);
  	}
  	V<int> X(N);
  	rep(i, N) cin >> X[i];

  	V<int> pos(N), fa(N, -1), L(N), R(N), H(N);
  	pos[0] = 0; 
  	int tt = 0;
  	auto dfs = [&](this auto && dfs, int u, int f) -> void {
  		fa[u] = f;
  		L[u] = tt + 1;
  		for(auto v : e[u]) if(v != f) {
				pos[v] = ++ tt;  			
  		}
  		H[u] = tt;
  		for(auto v : e[u]) if(v != f) {
  			dfs(v, u);
  		}
  		R[u] = tt;
  	};
  	dfs(0, -1);

  	dual_segment_tree<pmm> Segt(N, comp, pmm{mm(1), mm(0)});

  	rep(_, Q) {
  		int op; cin >> op;
  		if(op == 1) {
  			int V; cin >> V; -- V;
  			auto [a, b] = Segt[pos[V]];
  			cout << (a * X[V] + b).x << '\n';

  		} else if(op == 2) {
  			int V, K, C, D; cin >> V >> K >> C >> D; -- V;
  			pmm up{mm(C), mm(D)};
  			Segt.range_apply(pos[V], pos[V] + 1, up);
  			if(fa[V] != -1) Segt.range_apply(pos[fa[V]], pos[fa[V]] + 1, up);
  			if(L[V] <= H[V]) Segt.range_apply(L[V], H[V] + 1, up);

  		} else {
  			int V, C, D; cin >> V >> C >> D; -- V;
  			pmm up{mm(C), mm(D)};
  			Segt.range_apply(pos[V], pos[V] + 1, up);
  			if(L[V] <= R[V]) Segt.range_apply(L[V], R[V] + 1, up);
  		}
  	}
  }
};

#else
#include "cassert"
#include "cmath"
#include "cstdint"
#include "cstdio"
#include "cstdlib"
#include "cstring"
#include "algorithm"
#include "bitset"
#include "chrono"
#include "complex"
#include "deque"
#include "functional"
#include "iostream"
#include "limits"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "sstream"
#include "string"
#include "unordered_map"
#include "unordered_set"
#include "utility"
#include "vector"
#include "array"
using namespace std;
#define int long long
using ll = long long;
using ull = unsigned long long;
const ll INF = 1ll << 60;
const ll LINF = 0x1fffffffffffffff;
const ll MINF = 0x7fffffffffff;
template <class A, class B> bool chmax(A& l, const B& r){ return r > l ? l = r, 1 : 0; }
template <class A, class B> bool chmin(A& l, const B& r){ return r < l ? l = r, 1 : 0; }
#define sz(x) ssize(x)
#define rep(i, a) for(ll i = 0; i < (a); i ++)
#define Rep(i, a, b) for(ll i = (a); i < (b); i ++)
#define rrep(i, a, b) for(ll i = (b); i --> (a); )
#define all(x) begin(x), end(x)
#define fst first
#define snd second
#define pb push_back
template<class T> using V = vector<T>;
template<class T, std::size_t N> using AR = array<T, N>;
#define MAIN
#include __FILE__
signed main() {ios::sync_with_stdio(0);cin.tie(0);fixed(cout).precision(12);int t = 1;if(__multi__) cin >> t;while(t --) XK::solve();}
#endif