#include <bits/stdc++.h>
using namespace std;

int main() {
    int num_items, num_groups;
    cin >> num_items >> num_groups;

    vector<int> items(num_items);
    for (int i = 0; i < num_items; ++i) {
        cin >> items[i];
    }

    vector<int> group_sizes(num_groups);
    for (int i = 0; i < num_groups; ++i) {
        cin >> group_sizes[i];
    }

    sort(items.rbegin(), items.rend());

    int max_profit = 0;
    int idx = 0;
    for (int i = 0; i < num_groups; ++i) {
        int group_size = group_sizes[i];
        while (idx < num_items && group_size > 0) {
            max_profit += items[idx];
            idx++;
            group_size--;
        }
    }

    cout << max_profit << endl;

    return 0;
}

#include <bits/stdc++.h>
using namespace std;

int main()
{
    int numElements;
    cin >> numElements;
    vector<int64_t> minCost(numElements + 2, 0x3f3f3f3f3f3f3f3f);
    minCost[0] = 0;
    vector<int> range(numElements + 2), elementCost(numElements + 2);

    for (int i = 1; i <= numElements + 1; i++)
    {
        cin >> range[i];
    }
    for (int i = 1; i <= numElements + 1; i++)
    {
        cin >> elementCost[i];
    }

    for (int i = 1; i <= numElements + 1; i++)
    {
        if (range[i] == 0)
            continue;

        int nextIdx = min(i + range[i], numElements + 1);
        int prevIdx = max(i - range[i] - 1, 0);
        int64_t prevElementCost = elementCost[prevIdx];
        for (int j = prevIdx + 1; j <= nextIdx; j++)
        {
            minCost[j] = min(minCost[j], minCost[prevIdx] + elementCost[i]);
        }
    }

    cout << ((minCost[numElements + 1] < 0x3f3f3f3f3f3f3f3f) ? minCost[numElements + 1] : -1) << "\n";
}

#include <iostream>
using namespace std;

int findMaximum(int a, int b)
{
    return a > b ? a : b;
}

int findMinimum(int a, int b)
{
    return a < b ? a : b;
}

int main()
{
    int numRows, numCols;
    cin >> numRows >> numCols;

    int maximumValue = -0x3f3f3f3f;
    int result = -0x3f3f3f3f;
    for (int i = 0; i < numRows; i++)
    {
        for (int j = 0; j < numCols; j++)
        {
            int cellValue;
            cin >> cellValue;
            int currentDifference = maximumValue - cellValue;
            result = findMaximum(result, currentDifference);
            maximumValue = findMaximum(maximumValue, cellValue);
        }
    }
    cout << result << "\n";
}

#include <iostream>
#include <string>
using namespace std;

int main()
{
    int numElements;
    cin >> numElements;
    char prevChar, currentChar;
    cin >> currentChar;
    string result;

    for (int i = 2; i <= numElements; i++)
    {
        prevChar = currentChar;
        cin >> currentChar;
        if (currentChar == '*')
        {
            continue;
        }
        if (currentChar == '_' || currentChar == 'D')
        {
            if (prevChar == '*')
            {
                result.push_back('J');
            }
            else
            {
                result.push_back('W');
            }
        }
    }
    if (numElements == 1)
    {
        result = 'W';
    }
    cout << result << endl;
}

#include <bits/stdc++.h>
using namespace std;

using pii = pair<int, int>;
#define ll long long
#define test_cases  \
    int t;           \
    cin >> t;        \
    while (t--)
#define read_array              \
    int arr[n];                 \
    for (int i = 0; i < n; i++) \
    cin >> arr[i]

bool comparePair(pii p1, pii p2)
{
    if (p1.first < p2.first)
        return false;
    else if (p1.first > p2.first)
        return true;
    return p1.second < p2.second;
}

void findSolution()
{
    int numElements;
    cin >> numElements;
    int k;
    cin >> k;
    read_array;
    for (int i = 0; i < numElements; i++)
        arr[i] %= k;
    vector<int> ans;
    for (int i = 0; i < numElements; i++)
        if (arr[i] == 0)
            ans.push_back(i + 1);
    vector<pii> v(numElements);
    for (int i = 0; i < numElements; i++)
        v[i].first = arr[i], v[i].second = i + 1;
    sort(v.begin(), v.end(), comparePair);
    for (auto i : v)
        if (i.first != 0)
            ans.push_back(i.second);
    for (int k : ans)
        cout << k << ' ';
    cout << endl;
}

signed main()
{
    test_cases
    findSolution();
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

int calculateMaxRewards(int numDays, vector<int>& rewardValues, vector<int>& rewardReductions, vector<int>& rewardDays) {
    vector<int> maxRewards(numDays + 1, 0);

    for (int i = 1; i <= numDays; ++i) {
        maxRewards[i] = rewardValues[i - 1];
        for (int j = 1; j < i; ++j) {
            int remainingDays = rewardDays[i - j - 1] - (i - j);
            if (remainingDays > 0) {
                maxRewards[i] = max(maxRewards[i], maxRewards[j] + rewardValues[i - 1] - rewardReductions[i - 1] * remainingDays);
            }
        }
    }

    int overallMaxReward = 0;
    for (int i = 1; i <= numDays; ++i) {
        overallMaxReward = max(overallMaxReward, maxRewards[i]);
    }

    return overallMaxReward;
}

int main() {
    int numDays;
    cin >> numDays;

    vector<int> rewardValues(numDays);
    for (int i = 0; i < numDays; ++i) {
        cin >> rewardValues[i];
    }

    vector<int> rewardReductions(numDays);
    for (int i = 0; i < numDays; ++i) {
        cin >> rewardReductions[i];
    }

    vector<int> rewardDays(numDays);
    for (int i = 0; i < numDays; ++i) {
        cin >> rewardDays[i];
    }

    int maxReward = calculateMaxRewards(numDays, rewardValues, rewardReductions, rewardDays);
    cout << maxReward << endl;

    return 0;
}

unordered_map<string, int> memo;

int minCost(const vector<int>& lst, int x, int y, int pos, int curr, int count) {
    int minm = INT_MAX;
    string key = to_string(pos) + "|" + to_string(count);

    if (memo.find(key) != memo.end()) {
        return memo[key];
    }

    if (pos >= lst.size() && count == 0) {
        return curr;
    }

    if (pos >= lst.size()) {
        return minm;
    }

    if (count == 0) {
        return curr;
    }

    int c = minCost(lst, x, y, pos + y, lst[pos] + curr, count - 1);
    int s = minCost(lst, x, y, pos + 1, 0, x);
    minm = min(minm, min(c, s));
    memo[key] = minm;
    return minm;
}

int minRehabCost(const vector<int>& lst, int x, int y) {
    memo.clear();
    return minCost(lst, x, y, 0, 0, x);
} 

int solution(int N, vector<int>& A, vector<int>& B) {
    vector<vector<int>> graph(N);
    vector<int> edgesCount(N, 0);

    for (int i = 0; i < A.size(); i++) {
        edgesCount[A[i]]++;
        edgesCount[B[i]]++;
        graph[A[i]].push_back(B[i]);
        graph[B[i]].push_back(A[i]);
    }

    queue<int> q;
    for (int i = 0; i < N; i++) {
        if (edgesCount[i] <= 1) {
            q.push(i);
        }
    }

    int seconds = 0;
    while (!q.empty()) {
        int size = q.size();
        while (size > 0) {
            int vertex = q.front();
            q.pop();
            for (int neighbor : graph[vertex]) {
                if (edgesCount[neighbor] > 0) {
                    edgesCount[neighbor]--;
                    if (edgesCount[neighbor] == 1) {
                        q.push(neighbor);
                    }
                }
            }
            edgesCount[vertex] = 0;
            size--;
        }
        seconds++;
    }

    return seconds;
}

#define ll long long

int mod = 1e9 + 7;

ll calcpower(ll x, ll n)
{
    if (n == 1)
    {
        return x;
    }
    ll temp = calcpower(x, n / 2);
    if (n & 1)
    {
        return ((((x * temp) % mod) * temp) % mod);
    }
    return (temp * temp) % mod;
}

// Fermat's Little Theorem : a^p=a mod(p)  =>   a^(p-2)=(a^-1)mod(p)
ll modinv(ll num)
{
    return calcpower(num, mod - 2);
}

// Z-Algorithm
vector<int> calculateZ(string &s)
{
    vector<int> z(s.size(), 0);
    int l = 0;
    int r = 0;
    for (int k = 1; k < s.size(); k++)
    {
        if (k > r)
        {
            l = r = k;
            while (r < s.size() && s[r] == s[r - l])
            {
                r++;
            }
            z[k] = r - l;
            r--;
        }
        else
        {
            int k1 = k - l;
            if (z[k1] < r - k + 1)
            {
                z[k] = z[k1];
            }
            else
            {
                l = k;
                while (r < s.size() && s[r] == s[r - l])
                {
                    r++;
                }
                z[k] = r - l;
                r--;
            }
        }
    }
    return z;
}

int numberOfWays(string s, string t, long long k)
{
    if (s.size() != t.size())
    {
        return 0;
    }
    string temp = t;
    temp += '$';
    temp += s;
    temp += s;

    vector<int> z = calculateZ(temp);
    vector<long long> v;
    int n = s.size();
    if (k % 2 == 0)
    {
        v.resize(n, (((calcpower(n - 1, k) - 1) * modinv(n)) % mod));
        v[0] += 1;
        v[0] %= mod;
    }
    else
    {
        v.resize(n, (((calcpower(n - 1, k) + 1) * modinv(n)) % mod));
        v[0] -= 1;
        v[0] += mod;
        v[0] %= mod;
    }

    int ans = 0;
    for (int i = 0; i < z.size(); i++)
    {
        if (z[i] == t.size())
        {
            if (i - t.size() - 1 >= 0 && i - t.size() - 1 < n)
            {
                ans += v[i - t.size() - 1];
            }
            ans %= mod;
        }
    }

    return ans % mod;
}

int getNumWays(string src, string target, int k)
{
    return numberOfWays(src, target, k);
}

int countAnalogousArrays(vector<int>& arr, int lower, int higher) { 
    int max = std::numeric_limits<int>::min();  
    int n = lower; 
    for (int i = 0; i < arr.size(); i++) { 
        int k = arr[i]; 
        int k1 = n - k; 
 
        if (k1 > higher || k1 < lower) { 
            return 0; 
        } 
 
        n = k1; 
        max = std::max(max, n); 
    } 
 
    max = higher - max + 1; 
 
    return max; 
}

long getMaximumScore(vector<int> v)
{
    int n=v.size();
    map<int,vector<int>> mp; 
    for(int i=0;i<n;i++)
    {
       mp[v[i]-i].push_back(v[i]);
    }
    long ans=0;
    for(auto v:mp)
    {
        long sum=0;
        for(auto it: v.second)
        {
            sum+=it;
        }
        ans=max(sum,ans);
    }
    return ans;

}