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
