#include <bits/stdc++.h>

constexpr int INF = 1e9;

template<class Info>
struct SegmentTree
{
	int n;
	std::vector<Info> info;
	SegmentTree() : n(0) {}
	SegmentTree(int n_, Info v_ = Info())
	{
		init(n_, v_);
	}

	template<class T>
	SegmentTree(std::vector<T> init_)
	{
		init(init_);
	}
	void init(int n_, Info v_ = Info())
	{
		init(std::vector(n_, v_));
	}

	template<class T>
	void init(std::vector<T> init_)
	{
		n = init_.size();
		info.assign(4 << std::__lg(n), Info());
		std::function<void(int, int, int)> build = [&](int p, int l, int r)
		{
			if(r - l == 1)
			{
				info[p] = init_[l];
				return;
			}

			int mid = (l + r) >> 1;
			build(p << 1, l, mid);
			build(p << 1 | 1, mid, r);
			pull(p);
		};
		build(1, 0, n);
	}

	void pull(int p)
	{
		info[p] = info[p << 1] + info[p << 1 | 1];
	}

	void modify(int p, int l, int r, int x, const Info &v)
	{
		if(r - l == 1)
		{
			info[p] = v;
			return;
		}

		int mid = (l + r) >> 1;
		if(x < mid) modify(p << 1, l, mid, x, v);
		else modify(p << 1 | 1, mid, r, x, v);
		pull(p); 
	}
	void modify(int p, const Info &v)
	{
		modify(1, 0, n, p, v);
	}

	Info rangeQuery(int p, int l, int r, int x, int y)
	{
		if(l >= y || r <= x) return Info();
		if(l >= x && r <= y) return info[p];

		int mid = (l + r) >> 1;
		return rangeQuery(p << 1, l, mid, x, y) + rangeQuery(p << 1 | 1, mid, r, x, y);
	}
	Info rangeQuery(int l, int r)
	{
		return rangeQuery(1, 0, n, l, r);
	}

	template<class F>
	int findFirst(int p, int l, int r, int x, int y, F pred)
	{
		if(l >= y || r <= x || !pred(info[p])) return -1;
		if(r - l == 1) return l;

		int mid = (l + r) >> 1;
		int res = findFirst(p << 1, l, mid, x, y, pred);
		if(res == -1) res = findFirst(p << 1 | 1, mid, r, x, y, pred);

		return res;
	}
	template<class F>
	int findFirst(int l, int r, F pred)
	{
		return findFirst(1, 0, n, l, r, pred);
	}

	template<class F>
	int findLast(int p, int l, int r, int x, int y, F pred)
	{
		if(l >= y || r <= x || !pred(info[p])) return -1;
		if(r - l == 1) return l;

		int mid = (l + r) >> 1;
		int res = findLast(p << 1 | 1, mid, r, x, y, pred);
		if(res == -1) res = findLast(p << 1, l, mid, x, y, pred);

		return res;
	}
	template<class F>
	int findLast(int l, int r, F pred)
	{
		return findLast(1, 0, n, l, r, pred);
	}
};

struct Info
{
	int max = 0;
	int cnt = 0;
};
Info operator+(Info a, Info b)
{
	return {std::max(a.max, b.max), a.cnt + b.cnt};
}

void solve()
{
	int n, m, k; std::cin >> n >> m >> k;
	std::vector<int> a(n + 2), b(m), vis(n + 1);
	for(int i = 1; i <= n; i++) std::cin >> a[i];
	for(int i = 0; i < m; i++) std::cin >> b[i], vis[b[i]] = 1;

	std::vector<std::pair<int, int>> v;
	for(int i = 1; i <= n; i++) if(!vis[a[i]])
		v.emplace_back(a[i], i);
	std::ranges::sort(v, std::greater());

	std::vector<Info> init(n + 2);
	for(int i = 0; i <= n + 1; i++) init[i] = {a[i], 0};
	SegmentTree<Info> segt(init);

	std::multiset<int> L;
	L.emplace(0);
	for(int i = 0; i < k; i++)
	{
		int x; std::cin >> x;
		L.emplace(x);
	}

	for(auto [x, pos] : v)
	{
		int r = segt.findFirst(pos, n + 2, [&](Info info) -> bool
			{
				return info.max > x;
			});
		int l = segt.findLast(0, pos, [&](Info info) -> bool
			{
				return info.max > x;
			});

		int len = r - l - 1 - segt.rangeQuery(l, r).cnt;

		if(L.empty())
		{
			std::cout << "NO\n";
			return;
		}

		auto it = *std::prev(L.upper_bound(len));
		// std::cerr << it << " ";
		if(it == 0)
		{
			std::cout << "NO\n";
			return;
		}
		L.extract(it);
		segt.modify(pos, {0, 1});

		// for(auto i : L) std::cerr << i << " ";
		// std::cerr << "\n";
	}
	std::cout << "YES\n";
}

int main()
{
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);

	int t; std::cin >> t;
	while(t--) solve();

	return 0;
}

/*
1
3 2 2
3 1 2
3 2
2 3
*/