Problem: 2061D - Kevin and Numbers
Language: c++17 

Solution 1 (runtime: 936 ms):
#include <bits/stdc++.h>
#include <unordered_set>
#include <vector>
#include <stack>
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
#define ll long long
#define pb push_back
#define all(x) x.begin(), x.end()
#define loop(i, a, b) for (ll i = a; i < b; i++)
#define rloop(i, a, b) for (ll i = a; i >= b; i--)
#define sum(x) accumulate((x).begin(), (x).end(), 0LL)
#define maxi(x) *max_element((x).begin(), (x).end())
#define mini(x) *min_element((x).begin(), (x).end())
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
#define v(type) vector<type>
#define fi first
#define sec second
#define cin(x) cin >> x
#define print(a) for (auto& x : a) { cout << x << " "; } cout << endl;
#define print2(a) for (auto& x : a) { for (auto& y : x) { cout << y << " "; } cout << endl; }
#define test() ll tc; cin >> tc; while (tc--)
#define input(arr, n) v(ll) arr(n); for (ll i = 0; i < n; i++) cin >> arr[i];
#define read(n) ll n; cin >> n;
#define cout(type) cout << type << endl;
#define int long long int


// vector<int> find(vector<vector<int>> &data, vector<int> &queries){
// 	sort(data.begin(), data.end());
// 	priority_queue<int, vector<int>, greater<int>> pq;
// 	vector<pair<int, int>> queriesIndex;
// 	for(int i = 0; i<queries.size(); i++){
// 		queriesIndex.push_back({queries[i], i});
// 	}
// 	sort(queriesIndex.begin(), queriesIndex.end());
// 	int j = 0;
// 	vector<int> ans(queries.size());
// 	for(int i = 0; i<queries.size(); i++){
// 		while(j<data.size() and data[j][0] <= queriesIndex[i].first){
// 			pq.push(data[j][0] + data[j][1]);
// 			j++;
// 		}

// 		while(pq.size() and pq.top() < queriesIndex[i].first){
// 			pq.pop();
// 		}
// 		ans[queriesIndex[i].second] = pq.size();
// 	}
// 	return ans;
// }

// bool valid(int x, int y, int jump, vector<string> &grid){
// 	if(x < 0 || x >= grid.size() || y < 0 || y >= grid[0].size() || grid[x][y] == '#') return false;
// 	if(jump > 1){
// 		if(grid[x][y] == '*'){
// 			return true;
// 		}
// 	}
// 	else{
// 		if(grid[x][y] == '*'){
// 			grid[x][y] = '#';
// 			return true;
// 		}

// 		if(grid[x][y] == 'E'){
// 			return true;
// 		}
// 	}
// 	return false;

// }


// int question2(vector<string> &grid){
// 	queue<vector<int>> q;
// 	for(int i = 0; i<grid.size(); i++){
// 		for(int j = 0; j<grid[0].size(); j++){
// 			if(grid[i][j] == 'S'){
// 				q.push({i, j, 1});
// 			}
// 		}
// 	}
// 	int count = 1;
// 	while(q.size()){
// 		int size = q.size();
// 		for(int i = 0; i<size; i++){
// 			auto curr = q.front(); q.pop();
			
// 			if(curr[2] == 0 || curr[2] == 1){
// 				for(int k = curr[0] + 1; k<grid.size(); k++){
// 					if(valid(k, curr[1], k - curr[0], grid)){
// 						if(grid[k][curr[1]] == 'E') return count;
// 						int dir = k == curr[0] + 1 ? 0 : 1;
// 						q.push({k, curr[1], dir});
// 					}
// 				}
// 			}
// 			if(curr[2] == 0 || curr[2] == 2){
// 				for(int k = curr[0] - 1;  k>=0; k--){
// 					if(valid(k, curr[1],k - curr[0], grid)){
// 						if(grid[k][curr[1]] == 'E') return count;
// 						int dir = k == curr[0] - 1 ? 0 : 2;
// 						q.push({k, curr[1], dir});
// 					}
// 				}
// 			}
			
// 			if(curr[2] == 0 || curr[2] == 3){
// 				for(int k = curr[1] + 1; k<grid[0].size(); k++){
// 					if(valid(curr[0], k,k - curr[1], grid)){
// 						if(grid[curr[0]][k] == 'E') return count;
// 						int dir = k == curr[1] + 1 ? 0 : 3;
// 						q.push({curr[0],k, dir});
// 					}
// 				}
// 			}
// 			if(curr[2] == 0 || curr[2] == 4){
// 				for(int k = curr[1] - 1; k>=0; k--){
// 					if(valid(curr[0], k , k - curr[1],grid)){
// 						if(grid[curr[0]][k] == 'E') return count;
// 						int dir = k == curr[1] - 1 ? 0 : 4;
// 						q.push({curr[1], k,  dir});
// 					}
// 				}

// 			}	
// 		}
// 		count++;
// 	}
// 	return -1;
// }


// long countGoodSubsequences(vector<int> arr) {
//     map<int, int> mp;
//     for(int i: arr) mp[i]++;
//     unordered_set<int> visited;
//     long long ans = 0;
// 	for(auto i: mp){
// 		if(visited.find(i.first) == visited.end()){
// 			long long temp = i.second;
// 			int curr = i.first + 1;
// 			ans += i.second;
// 			visited.insert(i.first);
// 			while(mp.find(curr) != mp.end()){
// 				ans += temp*mp[curr];
// 				temp = temp*mp[curr];
// 				visited.insert(curr);
// 				curr++;
// 			}
// 		}
// 	}
// 	return ans;
// }

// void solve(){
// 	int n, d;
// 	cin >> n >> d;
// 	vector<int> ans = {1};
// 	if(d % 3 == 0 || n >= 3) ans.push_back(3);
// 	if(d == 5) ans.push_back(5);
// 	if(d == 7 || n >= 3) ans.push_back(7);
// 	if(d % 9 == 0 || n >= 6 || (d%3==0 and n>=3)){
// 		ans.push_back(9);
// 	}
// 	for(auto &i: ans){
// 		cout << i << " ";
// 	}
// 	cout << endl;
	
// }

// void doSolve(){
// 	int n;
// 	cin >> n;
// 	vector<int> arr(n);
// 	for(int i = 0; i<n; i++) cin >> arr[i];
// 	for(int i = 1; i<n; i++){
// 		if(arr[i - 1] > arr[i]){
// 			if(arr[i]*2 > arr[i - 1]){
// 				cout << "YES" << endl;
// 				return;
// 			}
// 		}
// 		else{
// 			if(arr[i - 1]*2 > arr[i]){
// 				cout << "YES" << endl;
// 				return;
// 			}
// 		}
// 	}
// 	cout << "NO" << endl;
// }


// int question1Solve(vector<int> &arr){

// 	int ans = 1, n = arr.size();
// 	vector<int> left(n, 1), right(n, 1);
// 	for(int i = 1; i<n; i++){
// 		if(arr[i] <= arr[i - 1]){
// 			left[i] = left[i - 1] + 1;
// 		}
// 	}
// 	for(int i = n - 2; i>=0; i--){
// 		if(arr[i] <= arr[i + 1]){
// 			right[i] = right[i + 1] + 1;
// 		}
// 	}
// 	for(int i = 0; i<n; i++){
// 		ans = max(ans, left[i] + right[i] - 1);
// 	}
// 	return ans;
// }

// int find(vector<int> &arr){
// 	int n = arr.size();

// 	int ans = 0;
// 	for(int i = 0; i<n - 3; i++){
// 		for(int j = i + 1; j<n - 2; j++){
// 			for(int k = j + 1; k<n - 1; k++){
// 				for(int l = k + 1; l<n; l++){
// 					if(arr[i]*arr[k] == arr[j]*arr[l]) ans++;
// 				}
// 			}
// 		}
// 	}
// 	return ans;
// }

// int gcd(int a, int b){
// 	if(b==0) return a;
// 	return gcd(b, a%b);
// }


// int cnt[1001][1001];
// long long numberOfSubsequences(vector<int>& n) {
//     long long res = 0;
//     memset(cnt, 0, sizeof(cnt));
//     for (int q = n.size() - 3; q > 0; --q) {
//         for (int s = q + 2, r = q + 1; s < n.size(); ++s) {
//             int f = gcd(n[r], n[s]);
//             ++cnt[n[r] / f][n[s] / f];
//         }                   
//         for (int p = 0; p < q; ++p) {
//             int f = gcd(n[p], n[q]);
//             res += cnt[n[q] / f][n[p] / f];
//         }
//     }
//     return res;
// }


void question34(){
	int n, m;
	cin >> n >> m;
	vector<int> b(m);
	map<int, int> a;
	int sum = 0;
	for(int i = 0; i<n; i++){
		int x;
		cin >> x;
		a[x]++;
		sum += x;
	}

	for(int j = 0; j<m; j++){
		cin >> b[j];
		sum -= b[j];
	}
	if(sum){
		cout << "NO" << endl;
		return;
	}
	while(b.size()){
		int ele = b.back();
		b.pop_back();
		if(a.find(ele) != a.end()){
			a[ele]--;
			if(a[ele] == 0){
				a.erase(ele);
			}
		}
		else{
			if(ele == 1){
				cout << "NO" << endl;
				return;
			}
			else{
				b.push_back(ele/2);
				b.push_back((ele + 1)/2);
			}
		}
	}
	cout << "YES" << endl;
}


int32_t main(){
	#ifndef ONLINE_JUDGE
	    // for getting input from input.txt
	    freopen("input.txt", "r", stdin);
	    // for writing output to output.txt
	    freopen("output.txt", "w", stdout);
	#endif

	int t;
	cin >> t;
	while(t--) question34();
}




Solution 2 (runtime: 359 ms):
#include<iostream>

#include<map>

using namespace std;

int t,n,m,a;

map<int,int>mp;

bool solve(int x)

{

    if(mp[x])

    {

        mp[x]--;

        return true;

    }

    else if(!x)return false;

    else return solve(x/2)&&solve((x+1)/2);

}

int main()

{

    scanf("%d",&t);

    while(t--)

    {

        mp.clear();

        scanf("%d%d",&n,&m);

        long long cnt=0;

        for(int i=0;i<n;i++)

        {

            scanf("%d",&a);

            mp[a]++;

            cnt+=a;

        }

        bool flag=true;

        for(int i=0;i<m;i++)

        {

            scanf("%d",&a);

            cnt-=a;

            if(flag&&!solve(a))flag=false;

        }

        if(flag&&!cnt)printf("Yes\n");

        else printf("No\n");

    }

    return 0;

}