#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <numeric>
#include <cstring>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <random>
#include <ctime>
#include <chrono>
#include <iomanip>
#include <array>
#include <cassert>

typedef long long ll;
typedef double lf;

// #define DEBUG 1
struct IO
{
    #define MAXSIZE (1 << 20)
    #define isdigit(x) (x >= '0' && x <= '9')
    char buf[MAXSIZE], *p1, *p2;
    char pbuf[MAXSIZE], *pp;
    #if DEBUG
    #else
    IO() : p1(buf), p2(buf), pp(pbuf) {}
    ~IO() {fwrite(pbuf, 1, pp - pbuf, stdout);}
    #endif
    #define gc() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, MAXSIZE, stdin), p1 == p2) ? ' ' : *p1++)
    #define blank(x) (x == ' ' || x == '\n' || x == '\r' || x == '\t')

    template <typename T>
    void Read(T &x)
    {
        #if DEBUG
        std::cin >> x;
        #else
        bool sign = 0; char ch = gc(); x = 0;
        for (; !isdigit(ch); ch = gc())
            if (ch == '-') sign = 1;
        for (; isdigit(ch); ch = gc()) x = x * 10 + (ch ^ 48);
        if (sign) x = -x;
        #endif
    }
    void Read(char *s)
    {
        #if DEBUG
        std::cin >> s;
        #else
        char ch = gc();
        for (; blank(ch); ch = gc());
        for (; !blank(ch); ch = gc()) *s++ = ch;
        *s = 0;
        #endif
    }
    void Read(char &c) {for (c = gc(); blank(c); c = gc());}

    void Push(const char &c)
    {
        #if DEBUG
        putchar(c);
        #else
        if (pp - pbuf == MAXSIZE) fwrite(pbuf, 1, MAXSIZE, stdout), pp = pbuf;
        *pp++ = c;
        #endif
    }
    template <typename T>
    void Write(T x)
    {
        if (x < 0) x = -x, Push('-');
        static T sta[35];
        int top = 0;
        do sta[top++] = x % 10, x /= 10; while (x);
        while (top) Push(sta[--top] ^ 48);
    }
    template <typename T>
    void Write(T x, char lst) {Write(x), Push(lst);}
} IO;
#define Read(x) IO.Read(x)
#define Write(x, y) IO.Write(x, y)
#define Put(x) IO.Push(x)

using namespace std;

const int MAXN = 1e5 + 10;

int n, q;
bool a[MAXN];
vector <int> e[MAXN];

int dep[MAXN], fa[MAXN], sz[MAXN], son[MAXN];
int dfn[MAXN], idx[MAXN], top[MAXN], clk, btm[MAXN];
void DFS1(int u, int t)
{
    dep[u] = dep[t] + 1, fa[u] = t, sz[u] = 1, son[u] = 0;
    for (auto v : e[u])
        if (v != t) DFS1(v, u), (sz[son[u]] < sz[v]) && (son[u] = v), sz[u] += sz[v];
}
void DFS2(int u, int t)
{
    dfn[u] = ++clk, idx[clk] = u, top[u] = t, btm[u] = u;
    if (son[u]) DFS2(son[u], t), btm[u] = btm[son[u]];
    for (auto v : e[u])
        if (v != fa[u] && v != son[u]) DFS2(v, v);
}

struct BIT
{
    bool bit[MAXN];
    inline void add(int x) { for (; x <= n; x += (x & -x)) bit[x] ^= 1; }
    inline void flip(int x) { add(dfn[x]), add(dfn[x] + sz[x]); }
    inline bool ask(int x) { bool res = 0; for (; x; x -= (x & -x)) res ^= bit[x]; return res; }
    inline bool ask(int u, int v) { if (dfn[v] < dfn[u]) return 0; return ask(dfn[v]) ^ ask(dfn[fa[u]]); }
}B;

typedef array <int, 2> arr;
struct SGT
{
    #define ls (p << 1)
    #define rs (p << 1 | 1)
    bool tag[MAXN << 2];
    arr tr[MAXN << 2];
    inline void Pushup(int p) { tr[p][0] = tr[ls][0] + tr[rs][0], tr[p][1] = tr[ls][1] + tr[rs][1]; }
    inline void Calc(int p) { swap(tr[p][0], tr[p][1]), tag[p] ^= 1; }
    inline void Pushdown(int p) { if (!tag[p]) return; Calc(ls), Calc(rs), tag[p] = 0; }
    void Build(int p, int l, int r)
    {
        tr[p][0] = tr[p][1] = tag[p] = 0;
        if (l == r) return;
        int mid = l + r >> 1;
        Build(ls, l, mid), Build(rs, mid + 1, r);
    }
    void Update(int p, int l, int r, int x, int y)
    {
        if (x > y) return;
        if (x <= l && r <= y) return Calc(p);
        Pushdown(p); int mid = l + r >> 1;
        if (x <= mid) Update(ls, l, mid, x, y);
        if (y > mid) Update(rs, mid + 1, r, x, y);
        Pushup(p);
    }
    void Modify(int p, int l, int r, int x, int k0, int k1)
    {
        if (l == r) return tr[p][0] += k0, tr[p][1] += k1, void();
        Pushdown(p); int mid = l + r >> 1;
        if (x <= mid) Modify(ls, l, mid, x, k0, k1);
        else Modify(rs, mid + 1, r, x, k0, k1);
        Pushup(p);
    }
    arr Query(int p, int l, int r, int x, int y)
    {
        if (x > y) return arr{0, 0};
        if (x <= l && r <= y) return tr[p];
        Pushdown(p); int mid = l + r >> 1; arr ret{0, 0}, cur;
        if (x <= mid) ret = Query(ls, l, mid, x, y);
        if (y > mid) cur = Query(rs, mid + 1, r, x, y), ret[0] += cur[0], ret[1] += cur[1];
        return ret;
    }
}T1, T2;

arr f[MAXN];

void Init(int u)
{
    bool c = B.ask(top[u], u);
    // cout << "In " << u << ' ' << c << '\n';
    T1.Modify(1, 1, n, dfn[u], c == 0, c == 1);
    T2.Modify(1, 1, n, dfn[u], (c ^ a[u]) == 0, (c ^ a[u]) == 1);
    for (auto v : e[u]) if (v != fa[u]) Init(v);
    if (top[u] == u && fa[u])
    {
        f[u] = T1.Query(1, 1, n, dfn[u], dfn[btm[u]]);
        c = B.ask(top[fa[u]], fa[u]);
        // cout << "# " << u << " " << f[u][0] << ' ' << f[u][1] << ' ' << c << '\n';
        T1.Modify(1, 1, n, dfn[fa[u]], f[u][c], f[u][!c]);
        c ^= a[fa[u]];
        T2.Modify(1, 1, n, dfn[fa[u]], f[u][c], f[u][!c]);
    }
    // for (int i = 1; i <= n; i++) cout << T1.Query(1, 1, n, dfn[i], dfn[i])[0] << ' '; cout << '\n';
}

void Update(int u)
{
    T1.Update(1, 1, n, dfn[u], dfn[btm[u]]), T2.Update(1, 1, n, dfn[u] + 1, dfn[btm[u]]);
    B.flip(u), a[u] ^= 1;
    while (fa[u = top[u]])
    {
        arr t = T1.Query(1, 1, n, dfn[u], dfn[btm[u]]);
        bool c = B.ask(top[fa[u]], fa[u]);
        T1.Modify(1, 1, n, dfn[fa[u]], t[c] - f[u][c], t[!c] - f[u][!c]);
        c ^= a[fa[u]];
        T2.Modify(1, 1, n, dfn[fa[u]], t[c] - f[u][c], t[!c] - f[u][!c]);
        f[u] = t, u = fa[u];
    }
}

void Solve(int u)
{
    int ans = 0;
    arr t = T1.Query(1, 1, n, dfn[u], dfn[btm[u]]); bool c = B.ask(top[u], u);
    ans += t[c ^ a[u] ^ 1];
    t = T2.Query(1, 1, n, dfn[top[u]], dfn[u] - 1);
    ans += t[c ^ 1];
    while (fa[u = top[u]])
    {
        ans -= f[u][c ^ a[fa[u]] ^ 1];
        c ^= B.ask(top[fa[u]], fa[u]);
        t = T1.Query(1, 1, n, dfn[fa[u]], dfn[btm[fa[u]]]);
        ans += t[c ^ a[fa[u]] ^ 1];
        t = T2.Query(1, 1, n, dfn[top[fa[u]]], dfn[fa[u]] - 1);
        ans += t[c ^ 1];
        u = fa[u];
    }
    cout << ans << '\n';
}

int main()
{
    // freopen(".in", "r", stdin);
    // freopen(".out", "w", stdout);
    #if DEBUG
    #else
    ios::sync_with_stdio(0), cin.tie(0);
    #endif
    int T;
    Read(T);
    while (T--)
    {
        Read(n), Read(q);
        for (int i = 1; i <= n; i++)
        {
            e[i].clear();
            B.bit[i] = 0;
            dep[i] = fa[i] = sz[i] = son[i] = 0;
            dfn[i] = idx[i] = top[i] = btm[i] = 0;
            f[i][0] = f[i][1] = 0;
        }
        clk = 0;
        for (int i = 1; i <= n; i++) Read(a[i]);
        for (int i = 1, u, v; i < n; i++) Read(u), Read(v), e[u].push_back(v), e[v].push_back(u);
        
        DFS1(1, 0), DFS2(1, 1);
        for (int i = 1; i <= n; i++) if (a[i]) B.flip(i);
        T1.Build(1, 1, n), T2.Build(1, 1, n);
        Init(1);
        
        // for (int i = 1; i <= n; i++) cout << dfn[i] << ' '; cout << "\n";
        // for (int i = 1; i <= n; i++) cout << T1.Query(1, 1, n, dfn[i], dfn[i])[0] << ' '; cout << '\n';
        // for (int i = 1; i <= n; i++) cout << T1.Query(1, 1, n, dfn[i], dfn[i])[1] << ' '; cout << '\n';
        // for (int i = 1; i <= n; i++) cout << T2.Query(1, 1, n, dfn[i], dfn[i])[0] << ' '; cout << '\n';
        // for (int i = 1; i <= n; i++) cout << T2.Query(1, 1, n, dfn[i], dfn[i])[1] << ' '; cout << '\n';

        int op, x, rt = 1;
        while (q--)
        {
            Read(op), Read(x);
            if (op == 1) Update(x);
            else rt = x;
            Solve(rt);
            // for (int i = 1; i <= n; i++) cout << T1.Query(1, 1, n, dfn[i], dfn[i])[0] << ' '; cout << '\n';
        }
    }
    return 0;
}