//Слава Україні, Героям слава

#include <bits/stdc++.h>

using namespace std;

struct seg_tree {
    //modify accordingly
    int n;
    vector<unsigned long long> v, lz, st;
    void build() {
        build(1, 1, n);
    }
    void build(int p, int l, int r) {
        if(l == r) {
            st[p] = v[l];
            return;
        }
        build(2 * p, l, (l + r) >> 1);
        build(2 * p + 1, ((l + r) >> 1) + 1, r);
        st[p] = st[2 * p] + st[2 * p + 1];
    }
    seg_tree(int n_ = 1) {
        n = n_;
        lz.resize(4 * n);
        st.resize(4 * n);
        v.resize(n + 1);
        build();
    }
    seg_tree(vector<unsigned long long> &v_) {
        v = v_;
        n = v.size();
        n--;
        lz.resize(4 * n);
        st.resize(4 * n);
        build();
    }
    void push(int p, int l, int r) {
        if(lz[p]) {
            st[p] = (r - l + 1) * lz[p];
            if(l != r) {
                lz[2 * p] = lz[p];
                lz[2 * p + 1] = lz[p];
            }
            lz[p] = 0;
        }
    }
    unsigned long long query(int i, int j) {
        return query(i, j, 1, 1, n);
    }
    unsigned long long query(int i, int j, int p, int l, int r) {
        push(p, l, r);
        if(l > j or r < i) {
            return 0;
        }
        if(l >= i and j >= r) {
            return st[p];
        }
        return query(i, j, 2 * p, l, (l + r) >> 1) + query(i, j, 2 * p + 1, ((l + r) >> 1) + 1, r);
    }
    void update(int i, int j, unsigned long long v) {
        update(i, j, v, 1, 1, n);
    }
    void update(int i, int j, unsigned long long v, int p, int l, int r) {
        push(p, l, r);
        if(l > j or r < i) {
            return;
        }
        if(l >= i and j >= r) {
            lz[p] = v;
            push(p, l, r);
            return;
        }
        update(i, j, v, 2 * p, l, (l + r) >> 1);
        update(i, j, v, 2 * p + 1, ((l + r) >> 1) + 1, r);
        st[p] = st[2 * p] + st[2 * p + 1];
    }
};

template <bool EDGE> struct HLD {
    vector<vector<int>> g1;
    vector<vector<pair<int, int>>> g2;
    vector<int> pos, sz, par, h;
    vector<unsigned long long> v, w, sobe;
    seg_tree seg;
    int t;
    HLD(int n) {
        if(EDGE) {
            g2.resize(n + 3);
        } else {
            g1.resize(n + 3);
        }
        pos.resize(n + 3); sz.resize(n + 3); par.resize(n + 3);
        if(EDGE) {
            sobe.resize(n + 3);
        } else {
            w.resize(n + 3);
        }
        h.resize(n + 3); v.resize(n + 3);
    }
    void build_hld(int k, int p = -1, int f = 1) {
        v[pos[k] = t++] = (EDGE ? sobe : w)[k]; sz[k] = 1;
        for(int i = 0; i < (int)(EDGE ? g2[k].size() : g1[k].size()); i++) {
            if((EDGE and g2[k][i].first != p) or (!EDGE and g1[k][i] != p)) {
                if(EDGE) {
                    sobe[g2[k][i].first] = g2[k][i].second; par[g2[k][i].first] = k;
                    h[g2[k][i].first] = (g2[k][i] == g2[k][0] ? h[k] : g2[k][i].first);
                    build_hld(g2[k][i].first, k, f); sz[k] += sz[g2[k][i].first];
                    if(sz[g2[k][i].first] > sz[g2[k][0].first] or g2[k][0].first == p) {
                        swap(g2[k][i], g2[k][0]);
                    }
                } else {
                    par[g1[k][i]] = k;
                    h[g1[k][i]] = (g1[k][i] == g1[k][0] ? h[k] : g1[k][i]);
                    build_hld(g1[k][i], k, f);
                    sz[k] += sz[g1[k][i]];
                    if(sz[g1[k][i]] > sz[g1[k][0]] or g1[k][0] == p) {
                        swap(g1[k][i], g1[k][0]);
                    }
                }
            }
        }
        if(p * f == -1) {
            t = 1;
            build_hld(h[k] = k, -1, 0);
        }
    }
    void add(int a, int b) {
        g1[a].push_back(b);
        g1[b].push_back(a);
    }
    void add(int a, int b, int x) {
        g2[a].push_back({b, x});
        g2[b].push_back({a, x});
    }
    void build(int root = 1) {
        t = 1;
        build_hld(root);
        seg = seg_tree(v);
    }
    unsigned long long query_path(int a, int b) {
        if(EDGE and a == b) return 0;
        if(pos[a] < pos[b]) swap(a, b);
        if(h[a] == h[b]) return seg.query(pos[b] + EDGE, pos[a]);
        return seg.query(pos[h[a]], pos[a]) + query_path(par[h[a]], b);
    }
    void update_path(int a, int b, unsigned long long x) {
        if(EDGE and a == b) return;
        if(pos[a] < pos[b]) swap(a, b);
        if(h[a] == h[b]) {
            seg.update(pos[b] + EDGE, pos[a], x);
            return;
        }
        seg.update(pos[h[a]], pos[a], x);
        update_path(par[h[a]], b, x);
    }
    unsigned long query_subtree(int a) {
        if(EDGE and sz[a] == 1) return 0;
        return seg.query(pos[a] + EDGE, pos[a] + sz[a] - 1);
    }
    void update_subtree(int a, int x) {
        if(EDGE and sz[a] == 1) return;
        seg.update(pos[a] + EDGE, pos[a] + sz[a] - 1, x);
    }
};

using ull = unsigned long long;

random_device rd;
mt19937 gen(rd());
uniform_int_distribution<ull> distrib(0, ULLONG_MAX);

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    int t;
    cin >> t;
    while(t--) {
        int n, q;
        cin >> n >> q;
        vector<unsigned long long> v(n + 3);
        vector<unsigned long long> hsh(n + 1), perm(n + 1);
        set<unsigned long long> st;
        for(int i = 1; i <= n; i++) {
            cin >> v[i];
            hsh[i] = distrib(gen);
            perm[i] = perm[i - 1] + hsh[i];
            st.insert(perm[i]);
        }
        HLD<false> hld(n);
        for(int i = 1; i <= n; i++) hld.w[i] = hsh[v[i]];
        for(int i = 1; i < n; i++) {
            int a, b;
            cin >> a >> b;
            hld.add(a, b);
        }
        hld.build();
        while(q--) {
            int t, a, b;
            cin >> t >> a >> b;
            if(t == 1) {
                unsigned long long x = hld.query_path(a, b);
                cout << (st.find(x) != st.end() ? "Yes\n" : "No\n");
            } else {
                hld.update_path(a, a, hsh[b]);
            }
        }
    }
    return 0;
}