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.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Text;
using System.Threading.Tasks;
using static System.Console;
using static System.Math;
class Z { static void Main() => new K(); }
class K
{
	int F => int.Parse(Str);
	long FL => long.Parse(Str);
	int[] G => Strs.Select(int.Parse).ToArray();
	long[] GL => Strs.Select(long.Parse).ToArray();
	string Str => ReadLine();
	string[] Strs => Str.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
	const int MOD = 1000000007;
	public K()
	{
		SetOut(new StreamWriter(OpenStandardOutput()) { AutoFlush = false });
		Solve();
		Out.Flush();
	}
	Random rand = new Random();
	int[] RandA(int n, int M)
	{
		var s = new SortedSet<int>();
		while (s.Count < n) s.Add(rand.Next(M));
		return s.ToArray();
	}
	int N;
	int[] A;
	long[,] sum;
	const bool Debug = false;
	void Solve()
	{
		var M = 1000;
		var st = DateTime.Now;
		var I = G;
		N = I[0];
		var Q = I[1];
		A = G;
		// A = RandA(N, M);
		// WriteLine(string.Join(" ", A));
		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(rand.Next(-10, M + 10)));
		for (var i = 0; i < Q; i++) { WriteLine(Solve(F)); }//if ((DateTime.Now - st).TotalSeconds >= 1.5) { var bomb = new long[120, 120, 155, 240]; bomb[0, 1, 2, 100] = F; rand.Next(bomb[0, 1, 2, 100]); } }
	}
	long Sum(int l, int r) => l >= r ? 0 : sum[r, (r - 1) % 2] - sum[l, (r - 1) % 2];
	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);
		if (Debug)
		{
			var r2 = Get2(x);
			if (!Eq(r, r2)) WriteLine($"x = {x}: {r} != {r2}");
		}
		if (r.Item1 == N) return Sum(0, N);
		if (r.Item1 == 0) return Sum2(r.Item2, N);
		return Sum2(r.Item2, N) + Sum(0, r.Item1 - (eventype ? 0 : 1));
	}
	bool Eq<S, T>(Tuple<S, T> a, Tuple<S, T> b) => a.Item1.Equals(b.Item1) && a.Item2.Equals(b.Item2);
	bool eventype;
	Tuple<int, int> Get(int x)
	{
		var k = FirstBinary(0, N, i => A[i] >= x);
		if (Abs(A[N - 1] - x) < Abs(A[N - 2] - x)) return new Tuple<int, int>(N, N);
		if (Debug)
		{
			var ans = GetAll(x, k);
			// for (var l = 0; l < N; l++) if (GetR(x, l, k) != GetR3(l, ans)) WriteLine($"GetR({x}, {l}, {k}) = {GetR(x, l, k)} != {GetR3(x, ans)}");
			for (var n = 0; n <= N; n++) if (!Eq(Get(x, n, k), ans[n])) WriteLine($"Get({x}, {n}, {k})");
		}
		var even = FirstBinary(0, 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; }
		return Get(x, FirstBinary(0, N / 2 + 1, n => n + 1 >= N - Get(x, n, k).Item2), k);
	}
	Tuple<int, int> Get2(int x)
	{
		var done = new bool[N];
		var ks = new List<Tuple<int, int>>();
		for (var i = 0; i < N; i++) ks.Add(new Tuple<int, int>(i, Abs(x - A[i])));
		ks.Sort((p, q) => { var c = p.Item2.CompareTo(q.Item2); if (c != 0) return c; return p.Item1.CompareTo(q.Item1); });
		var big = N - 1;
		var aoki = new List<int>();
		var j = 0;
		var ok = 0;
		var tak = true;
		while (ok < N)
		{
			if (tak)
			{
				if (done[big]) break;
				done[big--] = true;
				ok++;
			}
			else
			{
				var k = ks[j].Item1;
				if (done[k]) break;
				done[k] = true;
				aoki.Add(k);
				j++;
				ok++;
			}
			tak ^= true;
		}
		if (aoki.Count == 0) return new Tuple<int, int>(N, N);
		return new Tuple<int, int>(aoki.Min(), aoki.Max() + 1);
	}
	Tuple<int, int>[] GetAll(int x, int k)
	{
		var ks = new List<Tuple<int, int>>();
		for (var i = 0; i < N; i++) ks.Add(new Tuple<int, int>(i, Abs(x - A[i])));
		ks.Sort((p, q) => { var c = p.Item2.CompareTo(q.Item2); if (c != 0) return c; return p.Item1.CompareTo(q.Item1); });
		var ans = new Tuple<int, int>[N + 1];
		ans[0] = new Tuple<int, int>(k, k);
		int l = N, r = 0;
		for (var i = 0; i < N; i++)
		{
			l = Min(l, ks[i].Item1);
			r = Max(r, ks[i].Item1 + 1);
			ans[i + 1] = new Tuple<int, int>(l, r);
		}
		return ans;
	}
	Tuple<int, int> Get(int x, int n, int k)
	{
		Tuple<int, int> ans;
		if (x <= A[0]) { ans = new Tuple<int, int>(0, n); goto ret; }
		if (GetR(x, k, k) - k >= n) { ans = new Tuple<int, int>(k, k + n); goto ret; }
		// l<l' のとき [l, GetR(x, l, k))⊃[l', GetR(x, l', k))
		var hoge = FirstBinary(0, k, l => GetR(x, l, k) - l < n);
		ans = new Tuple<int, int>(hoge - 1, hoge - 1 + n);
	ret:
		if (!Good(x, ans.Item1, ans.Item2) || ans.Item2 - ans.Item1 != n) throw new Exception();
		return ans;
	}
	// k は A[k] >= x となる最小値
	// A[l] を取り, A[l-1] は取らないとき, 青木くんが取る一番右の index + 1
	// Good(x, l, r) が成り立つ最大の r
	int GetR(int x, int l, int k)
	{
		int ans;
		if (l == 0) { ans = N; goto ret; }
		if (Abs(A[l] - x) >= Abs(A[l - 1] - x)) { ans = l; goto ret; }
		if (Good(x, l, k) && !Good(x, l, k + 1)) { ans = k; goto ret; }
		ans = FirstBinary(k + 1, N, r => A[r] - x >= Abs(A[l - 1] - x));
	ret:
		if (!Good(x, l, ans) || Good(x, l, ans + 1)) throw new Exception();
		return ans;
	}
	// 青木くんが取る集合が [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;
		if (r < N) flag &= Abs(A[r] - x) >= Abs(A[r - 1] - x) && Abs(A[r] - x) >= Abs(A[l] - x);
		if (l > 0) flag &= Abs(A[l - 1] - x) > Abs(A[l] - x) && Abs(A[l - 1] - x) > Abs(A[r - 1] - 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;
	}
}