RT。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;

const int N = 1e5 + 5;

int a[N], dep[N], sz[N], son[N], fa[N], top[N], id[N], nw[N];

int n, m, r, p, cnt = 0;
vector<int> G[N];

inline void dfs1(int u, int father, int depth)
{
	sz[u] = 1;
	fa[u] = father;
	dep[u] = depth;
	for (int i = 0; i < G[u].size(); i++)
	{
		int nx = G[u][i];
		if (nx == father) continue;
		dfs1(nx, u, depth + 1);
		sz[u] += sz[nx];
		if (sz[son[u]] < sz[nx]) son[u] = nx;
	}
}

inline void dfs2(int u, int father)
{
	top[u] = father;
	id[u] = ++cnt;
	nw[cnt] = a[u];
	if (!son[u]) return;
	dfs2(son[u], father);
	for (int i = 0; i < G[u].size(); i++)
	{
		int nx = G[u][i];
		if (nx == son[u] || nx == father) continue;
		dfs2(nx, nx);
	}
}

struct Node
{
	int l, r, sum, add;
}tree[N << 2];

inline void push_up(int u)
{
	tree[u].sum = tree[u << 1].sum + tree[u << 1 | 1].sum;
}

inline void push_down(int u)
{
	Node& root = tree[u], &left = tree[u << 1], &right = tree[u << 1 | 1];
	if (root.add)
	{
		left.add += root.add;
		left.sum += (left.r - left.l + 1) * root.add;
		right.add += root.add;
		right.sum += (right.r - right.l + 1) * root.add;
		root.add = 0;
	}
}

inline void build(int u, int l, int r)
{
	tree[u] = { l, r };
	tree[u].add = 0;
	if (l == r)
	{
		tree[u].sum = nw[r];
	}
	else
	{
		int mid = (l + r) >> 1;
		build(u << 1, l, mid);
		build(u << 1 | 1, mid + 1, r);
		push_up(u);
	}
}

inline void update(int u, int l, int r, int k)
{
	if (tree[u].l >= l && tree[u].r <= r)
	{
		tree[u].add += k;
		tree[u].sum += (tree[u].r - tree[u].l + 1) * k;
	}
	else
	{
		push_down(u);
		int mid = (tree[u].l + tree[u].r) >> 1;
		if (l <= mid) update(u << 1, l, r, k);
		if (r > mid) update(u << 1 | 1, l, r, k);
		push_up(u);
	}
}

inline int query(int u, int l, int r)
{
	if (tree[u].l >= l && tree[u].r <= r) return tree[u].sum % p;
	push_down(u);
	int mid = (tree[u].l + tree[u].r) >> 1, res = 0;
	if (l <= mid) res = query(u << 1, l, r) % p;
	if (r > mid) res += query(u << 1 | 1, l, r);
	return res % p;
}

inline void update_path(int u, int v, int k)
{
	while (top[u] ^ top[v])
	{
		if (dep[top[u]] < dep[top[v]]) swap(u, v);
		update(1, id[top[u]], id[u], k);
		u = fa[top[u]];
	}
	if (dep[top[u]] < dep[top[v]]) swap(u, v);
	update(1, id[v], id[u], k);
}

inline void update_tree(int u, int k)
{
	update(1, id[u], id[u] + sz[u] - 1, k);
}

inline int query_path(int u, int v)
{
	int res = 0;
	while (top[u] ^ top[v])
	{
		if (dep[top[u]] < dep[top[v]]) swap(u, v);
		res += query(1, id[top[u]], id[u]);
		res %= p;
		u = fa[top[u]];
	}
	if (dep[top[u]] < dep[top[v]]) swap(u, v);
	res += query(1, id[v], id[u]);
	return res % p;
}

inline int query_tree(int u)
{
	return query(1, id[u], id[u] + sz[u] - 1) % p;
}

signed main()
{
	scanf("%d %d %d %d", &n, &m, &r, &p);
	for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
	for (int i = 1; i < n; i++)
	{
		int x, y;
		scanf("%d %d", &x, &y);
		G[x].push_back(y);
		G[y].push_back(x);
	}
	dfs1(r, -1, 1);
	dfs2(r, r);
	build(1, 1, n);
	while (m--)
	{
		int opt, l, r, k;
		scanf("%d %d", &opt, &l);
		if (opt == 1)
		{
			scanf("%d %d", &r, &k);
			update_path(l, r, k);
		}
		else if (opt == 2)
		{
			scanf("%d", &r);
			printf("%d\n", query_path(l, r));
		}
		else if (opt == 3)
		{
			scanf("%d", &k);
			update_tree(l, k);
		}
		else printf("%d\n", query_tree(l));
	}
	return 0;
}