#include <bits/stdc++.h>

using namespace std;
using ll = long long;

constexpr int Maxn = 2e5 + 3;
int cnt;
struct Segmentree {
    int maxx[Maxn * 4], lzt[Maxn * 4];

    int lc(int p) {return p << 1;}
    int rc(int p) {return p << 1 | 1;}

    void pushup(int p) {
        maxx[p] = max(maxx[lc(p)], maxx[rc(p)]);
    }

//    void pushdown(int l, int r, int mid, int p) {
//        if (!lzt[p]) return;
//        maxx[lc(p)] += lzt[p];
//        maxx[rc(p)] += lzt[p];
//        lzt[lc(p)] += lzt[p];
//        lzt[rc(p)] += lzt[p];
//        lzt[p] = 0;
//    }

    void build(int l, int r, int p, vector<int> &a) {
        if (l == r) {
            maxx[p] = a[l];
            lzt[p] = 0;
            return;
        }
        int mid = l + ((r - l) >> 1);
        build(l, mid, lc(p), a);
        build(mid + 1, r, rc(p), a);
        pushup(p);
    }

    //[l,r]是结点p覆盖的区间, [s,t]是要修改的区间
    void modify(int l, int r, int d, int s, int t, int p) {
        if (s <= l && r <= t) {
            maxx[p] += d;
//            lzt[p] += d;
            return;
        }
        int mid = l + ((r - l) >> 1);
//        pushdown(l, r, mid, p);
        if (s <= mid) modify(l, mid, d, s, t, lc(p));
        if (t > mid) modify(mid + 1, r, d, s, t, rc(p));
        pushup(p);
    }

    int query(int l, int r, int s, int t, int p) {
        if (s <= l && r <= t) return maxx[p];
        int mid = l + ((r - l) >> 1);
        int res = 0;
//        pushdown(l, r, mid, p);
        if (s <= mid) res = max(res, query(l, mid, s, t, lc(p)));
        if (t > mid) res = max(res, query(mid + 1, r, s, t, rc(p)));
        return res;
    }

    //从右往左找第一个大于val的位置, 从t到s
    int query1(int l, int r, int s, int t, int p, int val) {
        if (l == r) return l;
        int mid = l + ((r - l) >> 1);
//        pushdown(l, r, mid, p);
        int res = 0;
        if (t > mid) {
            if (maxx[rc(p)] > val) {
                res = query1(mid + 1, r, s, t, rc(p), val);
            }
        }
        if (res) return res;
        if (s <= mid) {
            if (maxx[lc(p)] > val) {
                res = query1(l, mid, s, t, lc(p), val);
            }
        }
        return res;
    }

    int query2(int l, int r, int s, int t, int p, int val) {
        if (l == r) return l;
        int mid = l + ((r - l) >> 1);
//        pushdown(l, r, mid, p);
        int res = 0;
        if (s <= mid) {
            if (maxx[lc(p)] > val) {
                res = query2(l, mid, s, t, lc(p), val);
            }
        }
        if (res) return res;
        if (t > mid) {
            if (maxx[rc(p)] > val) {
                res = query2(mid + 1, r, s, t, rc(p), val);
            }
        }
        return res;
    }
}seg;

struct Fenwick {
    int c[Maxn];

    void add(int x, int d, int n) {
        while (x <= n) {
            c[x] += d;
            x += x & -x;
        }
    }

    int ask(int x) {
        int res = 0;
        while (x) {
            res += c[x];
            x -= x & -x;
        }
        return res;
    }
}fwk;

int _;

void solve() {
    cnt++;
    int n, m, k;
    cin >> n >> m >> k;

    memset(fwk.c, 0, 4 * n + 1);

    vector<int> a(n + 1);
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
    }
    vector<int> b(m + 1);
    for (int i = 1; i <= m; ++i) {
        cin >> b[i];
    }
    vector<int> len(k + 1);
    multiset<int> s;
    for (int i = 1; i <= k; ++i) {
        cin >> len[i];
        s.insert(-len[i]);
    }

//    if (_ == 99 && cnt == 33) {
//        cout << n << ' ' << m << ' ' << k << '\n';
//        for (int i = 1; i <= n; ++i) {
//            cout << a[i] << " \n"[i == n];
//        }
//        for (int i = 1; i <= m; ++i) {
//            cout << b[i] << " \n"[i == m];
//        }
//        for (int i = 1; i <= k; ++i) {
//            cout << len[i] << " \n"[i == k];
//        }
//    }

    int it = 1;
    vector<array<int, 2> > tod;
    for (int i = 1; i <= n; ++i) {
        if (it <= m && a[i] == b[it]) {
            it++;
        } else {
            tod.push_back({a[i], i});
        }
    }
    if (it <= m) {
        cout << "NO\n";
        return;
    }

    sort(tod.begin(), tod.end(), greater());
//    for (int i = 0; i < ssize(tod); ++i) {
//        cerr << tod[i] << " \n"[i == ssize(tod) - 1];
//    }
    seg.build(1, n, 1, a);
//    cerr << seg.query1(1, n, 1, 4, 1, 5) << '\n';
//    cerr << seg.query2(1, n, 4, n, 1, 10) << '\n';
    for (int i = 0; i < ssize(tod); ++i) {
        int l = seg.query1(1, n, 1, tod[i][1], 1, tod[i][0]);
        if (!l) l = 1;
        else l++;
        int r = seg.query2(1, n, tod[i][1], n, 1, tod[i][0]);
        if (!r) r = n;
        else r--;
        int len = r - l + 1 - (fwk.ask(r) - fwk.ask(l - 1));
//        len = max(len, 0);
//        cerr << tod[i][0] << ' ' << l << ' ' << r << ' ' << len << " \n";
        auto f = s.lower_bound(-len);
//        cerr << *f << '\n';
        if (f == s.end()) {
            cout << "NO\n";
            return;
        } else {
            s.erase(f);
//            s.extract(-len);
            seg.modify(1, n, -tod[i][0], tod[i][1], tod[i][1], 1);
            fwk.add(tod[i][1], 1, n);
        }
    }

    cout << "YES\n";
}

int main() {
    cin.tie(nullptr) -> sync_with_stdio(false);

    cin >> _;
    for (int i = 1; i <= _; ++i) solve();

    return 0;
}