Problem:
Score : 500 points

Problem Statement

There are N cards. The i-th card has an integer A_i written on it.
For any two cards, the integers on those cards are different.

Using these cards, Takahashi and Aoki will play the following game:

Aoki chooses an integer x.

Starting from Takahashi, the two players alternately take a card. The card should be chosen in the following manner:

Takahashi should take the card with the largest integer among the remaining card.

Aoki should take the card with the integer closest to x among the remaining card. If there are multiple such cards, he should take the card with the smallest integer among those cards.

The game ends when there is no card remaining.

You are given Q candidates for the value of x: X_1, X_2, ..., X_Q.
For each i (1 \leq i \leq Q), find the sum of the integers written on the cards that Takahashi will take if Aoki chooses x = X_i.

Constraints

2 \leq N \leq 100 000

1 \leq Q \leq 100 000

1 \leq A_1 < A_2 < ... < A_N \leq 10^9

1 \leq X_i \leq 10^9 (1 \leq i \leq Q)

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N Q
A_1 A_2 ... A_N
X_1
X_2
:
X_Q

Output

Print Q lines. The i-th line (1 \leq i \leq Q) should contain the answer for x = X_i.

Sample Input 1

5 5
3 5 7 11 13
1
4
9
10
13

Sample Output 1

31
31
27
23
23

For example, when x = X_3(= 9), the game proceeds as follows:

Takahashi takes the card with 13.

Aoki takes the card with 7.

Takahashi takes the card with 11.

Aoki takes the card with 5.

Takahashi takes the card with 3.

Thus, 13 + 11 + 3 = 27 should be printed on the third line.

Sample Input 2

4 3
10 20 30 40
2
34
34

Sample Output 2

70
60
60

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.IO;
using System.Linq;
using static System.Console;
using static System.Math;
class Z { static void Main() => new K(); }
class K
{
	// 入力 1 行を読み取って int[] にして返す
	int[] G => ReadLine().Split().Select(int.Parse).ToArray();
	public K()
	{
		// 出力の flush を抑制
		SetOut(new StreamWriter(OpenStandardOutput()) { AutoFlush = false });
		Solve();
		Out.Flush();
	}
	int N;
	int[] A;
	// sum[n, i] = A[0,n) のうち, index の偶奇が i と一致するものの和
	long[,] sum;
	void Solve()
	{
		var I = G;
		N = I[0];
		var Q = I[1];
		A = G;
		sum = new long[N + 1, 2];
		for (var i = 0; i < N; i++) for (var j = 0; j < 2; j++) sum[i + 1, j] = sum[i, j] + (i % 2 == j ? A[i] : 0);
		for (var i = 0; i < Q; i++) WriteLine(Solve(G[0]));
	}
	// A[l,r) のうち, index の偶奇が右端 r-1 と一致するものの和
	long Sum(int l, int r) => l >= r ? 0 : sum[r, (r - 1) % 2] - sum[l, (r - 1) % 2];
	// A[l,r) の和
	long Sum2(int l, int r) => l >= r ? 0 : sum[r, 0] + sum[r, 1] - sum[l, 0] - sum[l, 1];
	long Solve(int x)
	{
		var r = Get(x);
		// 青木くんが 1 枚も取れない
		if (r.Item1 == N) return Sum(0, N);
		// 最後まで破綻しない
		if (r.Item1 == 0) return Sum2(r.Item2, N);
		// 青木くんが破綻した場合は, [l-1,r) までを青木くんが集め, [r,N) を高橋くんが集める
		return Sum2(r.Item2, N) + Sum(0, r.Item1 - (eventype ? 0 : 1));
	}
	bool eventype;
	// 青木くんが x に近い数を取り続ける / 高橋くんが大きい数を取り続ける
	// どちらかが最初に破綻するまでに, 青木くんが集めたカードの index のなす区間を返す
	// 高橋くんが破綻したときは eventype=true
	Tuple<int, int> Get(int x)
	{
		var k = FirstBinary(0, N, i => A[i] >= x);
		// 青木くんが 1 枚も取れない
		if (Abs(A[N - 1] - x) < Abs(A[N - 2] - x)) return new Tuple<int, int>(N, N);
		// 最後まで破綻しない
		if (Get(x, N / 2, k).Item1 == 0) return new Tuple<int, int>(0, N / 2);
		// 高橋くんが破綻するまでに n 枚ずつ取り, 青木くんが [l,r) を取ったとすると, 高橋くんは [r,N) を取っているはずで, N-r=nのはず
		// n を大きくしたとき, N-r は減少, n は増加するので, 最初に n>=N-r となる n について, n==N-r かを確認すれば良い
		var even = FirstBinary(1, N / 2 + 1, n => n >= N - Get(x, n, k).Item2);
		var le = Get(x, even, k);
		if (even == N - le.Item2) { eventype = true; return le; }
		// 青木くんが破綻するまでに n 枚取り, 高橋くんは n+1 枚取り, 青木くんが [l,r) を取ったとすると, 高橋くんは [r,N) を取っているはずで, N-r=n+1のはず
		// n を大きくしたとき, N-r は減少, n+1 は増加するので, 最初に n+1>=N-r となる n について, n+1==N-r かを確認すれば良い
		// WriteLine("odd");
		var odd = FirstBinary(1, N / 2 + 1, n => n + 1 >= N - Get(x, n, k).Item2);
		var lo = Get(x, odd, k);
		return lo;
	}
	// 高橋くんの存在を無視し, 青木くんが x に近い方から n 枚取ったときに, 青木くんが集めたカードの index のなす区間を返す
	Tuple<int, int> Get(int x, int n, int k)
	{
		// l が大きいほど [l,r) は狭くなる
		// 区間の長さが n 以上である最大の l について, [l, l+n) が答え
		var hoge = FirstBinary(0, k + 1, l => GetR(x, l, k) - l < n) - 1;
		return new Tuple<int, int>(hoge, hoge + n);
	}
	// 高橋くんの存在を無視し, 青木くんが x に近い方から順番に取ったときに,
	// 青木くんが集めたカードの index のなす区間の左端が l であるような区間たちの, 右端の最大値を返す
	// Good(x,l,r) が成り立つ r の最大値に等しい(はず)
	// [l,r) は r<k になりえず, k+1<=l にもなりえない
	int GetR(int x, int l, int k)
	{
		// 最終的にはすべて集めうる
		if (l == 0) return N;
		// A[l-1] のほうが A[l] よりも x に近ければ, 区間の左端が l になることはないので, 空の区間を返す
		if (Abs(A[l] - x) >= Abs(A[l - 1] - x)) return l;
		// [l,k) が答えになるときだけ特別扱い
		if (Good(x, l, k) && !Good(x, l, k + 1)) return k;
		// [l,r) は k を含むはずで, A[l] は集めて A[l-1] は集めていないのだから, A[l-1] よりも x に近いものを全部集めればいい
		return FirstBinary(k + 1, N, r => A[r] - x >= Abs(A[l - 1] - x));
	}
	// 高橋くんの存在を無視し, 青木くんが x に近い方から順番に取ったときに,
	// 青木くんが集めたカードの index のなす区間が [l,r) になりうるか
	bool Good(int x, int l, int r)
	{
		if (l == r) return true;
		if (l > r || l < 0 || r > N) return false;
		var flag = true;
		// A[r] を取っていないのに A[r-1],A[l] は取っている
		if (r < N) flag &= Abs(A[r] - x) >= Abs(A[r - 1] - x) && Abs(A[r] - x) >= Abs(A[l] - x);
		// A[l-1] を取っていないのに A[r-1],A[l] は取っている
		if (l > 0) flag &= Abs(A[l - 1] - x) > Abs(A[r - 1] - x) && Abs(A[l - 1] - x) > Abs(A[l] - x);
		return flag;
	}
	public static int FirstBinary(int min, int max, Predicate<int> pred)
	{
		while (min < max)
		{
			var mid = (min + max) / 2;
			if (pred(mid)) max = mid;
			else min = mid + 1;
		}
		return min;
	}
}