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 LuaJIT (2.0.4) (judge verdict: Accepted)

local mfl = math.floor

local function comp(a, b)
  return a < b
end

local function lower_bound(ary, x)
  local num = #ary
  if num == 0 then return 1 end
  if not comp(ary[1], x) then return 1 end
  if comp(ary[num], x) then return num + 1 end
  local min, max = 1, num
  while 1 < max - min do
    local mid = mfl((min + max) / 2)
    if comp(ary[mid], x) then
      min = mid
    else
      max = mid
    end
  end
  return max
end

local function upper_bound(ary, x)
  local num = #ary
  if num == 0 then return 1 end
  if comp(x, ary[1]) then return 1 end
  if not comp(x, ary[num]) then return num + 1 end
  local min, max = 1, num
  while 1 < max - min do
    local mid = mfl((min + max) / 2)
    if not comp(x, ary[mid]) then
      min = mid
    else
      max = mid
    end
  end
  return max
end

local n, q = io.read("*n", "*n")
local a = {io.read("*n")}
local asum = {a[1]}
for i = 2, n do
  a[i] = io.read("*n")
  asum[i] = asum[i - 1] + a[i]
end
local oddsum = {a[1]}
for i = 2, n do
  if i % 2 == 0 then
    oddsum[i] = oddsum[i - 1]
  else
    oddsum[i] = oddsum[i - 1] + a[i]
  end
end

local function get_ao_state(x, taka_count)
  local p_right = n - taka_count
  local len = a[p_right] - x
  if len <= 0 then
    -- taka_count should be smaller
    return true, 0
  end
  local p_left = lower_bound(a, x - len)
  local need_ao_count = p_right - p_left + 1
  if taka_count < need_ao_count then
    -- taka_count should be larger
    return false
  else
    return true, need_ao_count
  end
end

for iq = 1, q do
  local x = io.read("*n")
  local x_lbpos = lower_bound(a, x)
  local taka_count_lim = n + 1 - x_lbpos
  local taka_count, ao_count = 0, 0
  if 0 < taka_count_lim then
    local f = get_ao_state(x, 0)
    if not f then
      local min, max = 0, taka_count_lim
      while 1 < max - min do
        local mid = mfl((max + min) / 2)
        if get_ao_state(x, mid) then
          max = mid
        else
          min = mid
        end
      end
      taka_count = max
    end
  end
  local _u, ao_count = get_ao_state(x, taka_count)
  if ao_count < taka_count - 1 then
    ao_count = taka_count - 1
  end
  local takasum = asum[n] - asum[n - taka_count]
  local rem = n - taka_count - ao_count
  if 0 < rem then
    if rem % 2 == 0 then
      if ao_count < taka_count then
        takasum = takasum + oddsum[n - taka_count - ao_count]
      else
        takasum = takasum + asum[n - taka_count - ao_count] - oddsum[n - taka_count - ao_count]
      end
    else
      if ao_count < taka_count then
        takasum = takasum + asum[n - taka_count - ao_count] - oddsum[n - taka_count - ao_count]
      else
        takasum = takasum + oddsum[n - taka_count - ao_count]
      end
    end
  end
  print(takasum)
end