#include <bits/stdc++.h>
using namespace std;

using i64 = long long;
using ui64 = unsigned long long;
using i128 = __int128;
using ui128 = unsigned __int128;
using f4 = float;
using f8 = double;
using f16 = long double;

template<class T>
bool chmax(T &a, const T &b){
	if(a < b){ a = b; return true; }
	return false;
}

template<class T>
bool chmin(T &a, const T &b){
	if(a > b){ a = b; return true; }
	return false;
}

namespace Fastio {}
using Fastio::qin;
using Fastio::qout;

constexpr i64 inf = 4e18;

struct line {
    int k; i64 b;
    inline line() : line(0, 0) {}
    inline line(int _k, i64 _b): k(_k), b(_b) {}
    inline void add(i64 v) { b += k * v; }
};

inline line operator+(const line& lhs, const line& rhs) {
    return line(lhs.k + rhs.k, lhs.b + rhs.b);
}

inline pair<line, i64> _max(const line& a, const line& b) {
    if (a.k < b.k || (a.k == b.k && a.b < b.b)) return _max(b, a);
    if (a.b >= b.b) return make_pair(a, inf);
    return make_pair(b, (b.b - a.b) / (a.k - b.k));
}

struct info {
	line pre, suf, ans, sum;
	i64 x;
	inline info() {}
	inline info(line pre, line suf, line ans, line sum, i64 x)
	    : pre(pre), suf(suf), ans(ans), sum(sum), x(x) {}
};

inline info operator+(const info& a, const info& b) {
	i64 x0 = min(a.x, b.x);
	line sum = a.sum + b.sum;
	auto [pre, x1] = _max(a.pre, a.sum + b.pre);
	auto [suf, x2] = _max(b.suf, a.suf + b.sum);
	auto [tmp, x3] = _max(a.ans, b.ans);
	auto [ans, x4] = _max(tmp, a.suf + b.pre);
	return info(pre, suf, ans, sum, min({x0, x1, x2, x3, x4}));
}

inline void operator+=(info& a, i64 v) {
	a.x -= v;
    a.pre.add(v), a.suf.add(v);
    a.sum.add(v), a.ans.add(v);
}

struct node {
    int l, r;
    info dat;
    i64 tag;
};

inline int ls(int u) { return 2 * u + 1; }
inline int rs(int u) { return 2 * u + 2; }

struct ktt {
	vector<node> tr;
	inline ktt() {}
	inline ktt(const vector<i64>& a) {
		const int n = a.size();
		tr.resize(n << 2);
		build(0, 0, n - 1, a);
	}
	
	inline void pushup(int u) { tr[u].dat = tr[ls(u)].dat + tr[rs(u)].dat; }
	inline void apply(int u, i64 v) { tr[u].tag += v, tr[u].dat += v; }
	
	inline void pushdown(int u) {
	    if (tr[u].tag) {
	        apply(ls(u), tr[u].tag);
	        apply(rs(u), tr[u].tag);
	        tr[u].tag = 0;
	    }
	}
	
	inline void build(int u, int l, int r, const vector<i64>& a) {
	    tr[u].l = l, tr[u].r = r;
	    if (l == r) {
	        line f(1, a[l]);
	        tr[u].dat = info(f, f, f, f, inf);
	        return;
	    }
	    
	    const int mid = (l + r) >> 1;
	    build(ls(u), l, mid, a);
	    build(rs(u), mid + 1, r, a);
	    pushup(u);
	}
	
	inline void defeat(int u, i64 v) {
        const int mid = (tr[u].l + tr[u].r) >> 1;
	    if (v > tr[u].dat.x) {
	        defeat(ls(u), tr[u].tag + v);
	        defeat(rs(u), tr[u].tag + v);
	        tr[u].tag = 0;
	        pushup(u);
	    }
	    else apply(u, v);
	}
};

struct query {
	i64 x; int id;
	inline query() {}
	inline query(i64 x, int id) : x(x), id(id) {}
	inline bool operator<(const query& b) const {
		return x < b.x;
	}
};

signed main() {
	ios::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	
	int n, q;
	qin >> n >> q;
	
	vector<i64> a(n);
	for (int i = 0; i < n; i++) qin >> a[i];
	
	vector<query> que(q);
	for (int i = 0; i < q; i++) qin >> que[i].x, que[i].id = i;
	sort(que.begin(), que.end());
	for (int i = 0; i < n; i++) a[i] += que[0].x;
	
	ktt tree(a);
    vector<i64> ans(q);
	ans[que[0].id] = tree.tr[0].dat.ans.b;
	
	for (int i = 1; i < q; i++) {
		tree.defeat(0, que[i].x - que[i - 1].x);
		ans[que[i].id] = tree.tr[0].dat.ans.b;
	}
    for (int i = 0; i < q; i++) cout << ans[i] << '\n';
    
	return 0;
}