Problem: My futon

You bought N futons in preparation for your new life. The i-th futon has the warmth supply capacity of si. From the temperature forecast for the next M days, the warmth demand of dj is expected on the jth day. If the warmth is not enough or too much, the comfort will be impaired, so the absolute value of the difference between the sum of the warmth supply capacity of the futon on the j day and the dj is called the discomfort on the j day. To do. I want to make the total discomfort for M days as small as possible.

By the way, your room is unfortunately very small, with only a bed and a closet. Therefore, the only way to add one futon to the bed is to put the futon at the top of the closet on the top of the bed. Conversely, the only way to reduce one bed futon is to put the futon at the top of the bed at the top of the closet. There is no limit to the number of futons that can be moved per day, but only one can be moved at a time.

By the way, you plan to put the futon you bought in the closet. Only at this time can the futons be put in the closet in any order. How do you store your futon in the closet, and then how do you put it in and out every day so that you can spend your days comfortably? When minimizing the sum of discomfort for M days, find the value of that sum. There may be futons that have never been used, and there may be days when no futons are used.

Input

The input consists of multiple datasets. Each dataset has the following format.

> N M
> s1 s2 ... sN
> d1 d2 ... dM

The first line of the dataset is given an integer representing the number of futons N and the number of days M for which the temperature is predicted, separated by spaces. On the second line, N integers s1, s2, ..., sN are given separated by spaces, and si represents the warmth supply capacity of the i-th futon. On the third line, M integers d1, d2, ..., dM are given separated by spaces, and dj represents the warmth demand on day j. These integers satisfy 1 ≤ N ≤ 15, 1 ≤ M ≤ 100, 1 ≤ si, dj ≤ 1,000,000.

The end of the input is represented by a dataset of N = M = 0. Do not output for this dataset.

Output

For each dataset, output the minimum sum of discomfort for M days on one line.

Sample Input


1 1
Five
6
1 1
Five
2
1 1
20
Five
4 1
2 4 5 9
8
4 3
3 5 2 1
10 4 7
5 5
2 2 2 2 2
1 3 5 7 9
twenty five
twenty five
2 5 2 5 2
0 0

Output for Sample Input


1
2
Five
1
1
Five
Four


For the 5th case, put it in the closet with 5, 2, 3, 1 from the top, and take out 3 sheets on the 1st day | 10-(5 + 2 + 3) | = 0, 2 sheets on the 2nd day | 4 -5 | = Take out one sheet on the 1st and 3rd days | 7-(5 + 2) | = 0, for a total of 0 + 1 + 0 = 1.





Example

Input

1 1
5
6
1 1
5
2
1 1
20
5
4 1
2 4 5 9
8
4 3
3 5 2 1
10 4 7
5 5
2 2 2 2 2
1 3 5 7 9
2 5
2 5
2 5 2 5 2
0 0


Output

1
2
5
1
1
5
4

Solution (in CPP):

Solution:
#include <iostream>
#include <vector>
#include <algorithm>
#include <utility>
#include <queue>
#define inf 1e9

using namespace std;
typedef pair<int, int> P;

struct edge{
	int to, cost;
	edge(){}
	edge(int a, int b){
		to = a, cost = b;
	}
};

int N, M, S;
int s[20];
int d[105];
int sum[40000];
vector<edge> G[40000];
int dist[40000];

void dijkstra()
{
	for(int i = 0; i < S; i++) dist[i] = inf;
	dist[0] = 0;
	
	priority_queue< P, vector<P>, greater<P> > Q;
	Q.push( make_pair(0, 0) );
	
	int v, d;
	while(Q.size()){
		d = Q.top().first;
		v = Q.top().second;
		Q.pop();
		if(dist[v] < d) continue;
		for(int i = 0; i < G[v].size(); i++){
			if(dist[G[v][i].to] > d + G[v][i].cost){
				dist[G[v][i].to] = d + G[v][i].cost;
				Q.push( make_pair(dist[G[v][i].to], G[v][i].to) );
			}
		}
	}
}

int main(void)
{
	while(1){
		cin >> N >> M;
		if(N == 0 && M == 0) break;
		
		for(int i = 0; i < N; i++) cin >> s[i];
		for(int i = 0; i < M; i++) cin >> d[i];
		sort(d, d+M);
		
		S = 1 << N;
		for(int i = 0; i < S; i++){
			sum[i] = 0;
			for(int j = 0; j < N; j++){
				if(i & (1 << j)) sum[i] += s[j];
			}
		}
		
		for(int i = 0; i < S; i++) G[i].clear();
		for(int i = 0; i < S; i++){
			for(int j = 0; j < N; j++){
				if(i & (1 << j)) continue;
				int cost = 0;
				for(int k = 0; k < M; k++){
					if(d[k] > sum[i] && d[k] < sum[i | (1<<j)]){
						cost += min(d[k] - sum[i], sum[i | (1<<j)] - d[k]);
					}
				}
				G[i].push_back(edge(i | (1<<j), cost));
			}
		}
		
		dijkstra();
		
		int ans = dist[S-1];
		for(int i = 0; i < M; i++){
			if(sum[S-1] < d[i]) ans += d[i] - sum[S-1];
		}
		cout << ans << endl;
	}
	
	return 0;
}